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
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 457 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471
 472
 473 // add here SWIG version check
 474
 475 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 476 // disable Swig-dependent warnings
 477
 478 // 'identifier1' has C-linkage specified,
 479 // but returns UDT 'identifier2' which is incompatible with C
 480 #pragma warning(disable: 4190)
 481
 482 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 483 #pragma warning(disable: 4800)
 484
 485 // debug info too long etc etc
 486 #pragma warning(disable: 4786)
 487 #endif
 488
 489
 490 #include <stdexcept>
 491
 492
 493 #include <string>
 494
 495
 496 #include <vector>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <map>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <utility>
 507
 508
 509 typedef float floatp;
 510
 511 SWIGINTERN floatp *new_floatp(){
 512   return new float();
 513 }
 514 SWIGINTERN void delete_floatp(floatp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void floatp_assign(floatp *self,float value){
 518   *self = value;
 519 }
 520 SWIGINTERN float floatp_value(floatp *self){
 521   return *self;
 522 }
 523 SWIGINTERN float *floatp_cast(floatp *self){
 524   return self;
 525 }
 526 SWIGINTERN floatp *floatp_frompointer(float *t){
 527   return (floatp *) t;
 528 }
 529
 530 typedef int intp;
 531
 532 SWIGINTERN intp *new_intp(){
 533   return new int();
 534 }
 535 SWIGINTERN void delete_intp(intp *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void intp_assign(intp *self,int value){
 539   *self = value;
 540 }
 541 SWIGINTERN int intp_value(intp *self){
 542   return *self;
 543 }
 544 SWIGINTERN int *intp_cast(intp *self){
 545   return self;
 546 }
 547 SWIGINTERN intp *intp_frompointer(int *t){
 548   return (intp *) t;
 549 }
 550
 551 typedef double doublep;
 552
 553 SWIGINTERN doublep *new_doublep(){
 554   return new double();
 555 }
 556 SWIGINTERN void delete_doublep(doublep *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void doublep_assign(doublep *self,double value){
 560   *self = value;
 561 }
 562 SWIGINTERN double doublep_value(doublep *self){
 563   return *self;
 564 }
 565 SWIGINTERN double *doublep_cast(doublep *self){
 566   return self;
 567 }
 568 SWIGINTERN doublep *doublep_frompointer(double *t){
 569   return (doublep *) t;
 570 }
 571
 572 typedef unsigned int uintp;
 573
 574 SWIGINTERN uintp *new_uintp(){
 575   return new unsigned int();
 576 }
 577 SWIGINTERN void delete_uintp(uintp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned int uintp_value(uintp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 587   return self;
 588 }
 589 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 590   return (uintp *) t;
 591 }
 592
 593 typedef unsigned short ushortp;
 594
 595 SWIGINTERN ushortp *new_ushortp(){
 596   return new unsigned short();
 597 }
 598 SWIGINTERN void delete_ushortp(ushortp *self){
 599   if (self) delete self;
 600 }
 601 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 602   *self = value;
 603 }
 604 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 605   return *self;
 606 }
 607 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 608   return self;
 609 }
 610 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 611   return (ushortp *) t;
 612 }
 613
 614 unsigned int int_to_uint(int x) {
 615    return (unsigned int) x;
 616 }
 617
 618
 619 using namespace Dali;
 620 using namespace Dali::Toolkit;
 621
 622 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 623
 624      // C++ code. DALi uses Handle <-> Body design pattern.
 625      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 626      // Handles in DALi can be converted into a boolean type
 627      // to check if the handle has a valid body attached to it.
 628      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 629      if( *self )
 630      {
 631        return true;
 632      }
 633      else
 634      {
 635        return false;
 636      }
 637     }
 638 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 639
 640      // C++ code. Check if two handles reference the same implemtion
 641      if( *self == rhs)
 642      {
 643        return true;
 644      }
 645      else
 646      {
 647        return false;
 648      }
 649     }
 650 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 651      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 652    }
 653 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 654      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 655    }
 656 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 657         std::vector< Dali::TouchPoint >* pv = 0;
 658         if (capacity >= 0) {
 659           pv = new std::vector< Dali::TouchPoint >();
 660           pv->reserve(capacity);
 661        } else {
 662           throw std::out_of_range("capacity");
 663        }
 664        return pv;
 665       }
 666 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 667         if (index>=0 && index<(int)self->size())
 668           return (*self)[index];
 669         else
 670           throw std::out_of_range("index");
 671       }
 672 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 673         if (index>=0 && index<(int)self->size())
 674           return (*self)[index];
 675         else
 676           throw std::out_of_range("index");
 677       }
 678 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 679         if (index>=0 && index<(int)self->size())
 680           (*self)[index] = val;
 681         else
 682           throw std::out_of_range("index");
 683       }
 684 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 685         self->insert(self->end(), values.begin(), values.end());
 686       }
 687 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 688         if (index < 0)
 689           throw std::out_of_range("index");
 690         if (count < 0)
 691           throw std::out_of_range("count");
 692         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 693           throw std::invalid_argument("invalid range");
 694         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 695       }
 696 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 697         if (index>=0 && index<(int)self->size()+1)
 698           self->insert(self->begin()+index, x);
 699         else
 700           throw std::out_of_range("index");
 701       }
 702 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 703         if (index>=0 && index<(int)self->size()+1)
 704           self->insert(self->begin()+index, values.begin(), values.end());
 705         else
 706           throw std::out_of_range("index");
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 709         if (index>=0 && index<(int)self->size())
 710           self->erase(self->begin() + index);
 711         else
 712           throw std::out_of_range("index");
 713       }
 714 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 715         if (index < 0)
 716           throw std::out_of_range("index");
 717         if (count < 0)
 718           throw std::out_of_range("count");
 719         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 720           throw std::invalid_argument("invalid range");
 721         self->erase(self->begin()+index, self->begin()+index+count);
 722       }
 723 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 724         if (count < 0)
 725           throw std::out_of_range("count");
 726         return new std::vector< Dali::TouchPoint >(count, value);
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 729         std::reverse(self->begin(), self->end());
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (count < 0)
 735           throw std::out_of_range("count");
 736         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 737           throw std::invalid_argument("invalid range");
 738         std::reverse(self->begin()+index, self->begin()+index+count);
 739       }
 740 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 741         if (index < 0)
 742           throw std::out_of_range("index");
 743         if (index+values.size() > self->size())
 744           throw std::out_of_range("index");
 745         std::copy(values.begin(), values.end(), self->begin()+index);
 746       }
 747 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 748          return self->Empty();
 749       }
 750 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 751         return self->GetConnectionCount();
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Connect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Disconnect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 760           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 761 /*@SWIG@*/ self->Emit( arg );
 762       }
 763 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764          return self->Empty();
 765       }
 766 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767         return self->GetConnectionCount();
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Connect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Disconnect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 776           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 777 /*@SWIG@*/ self->Emit( arg );
 778       }
 779 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 780          return self->Empty();
 781       }
 782 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 783         return self->GetConnectionCount();
 784       }
 785 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 786           self->Connect( func );
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 789           self->Disconnect( func );
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 792           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 793 /*@SWIG@*/ self->Emit( arg );
 794       }
 795 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796          return self->Empty();
 797       }
 798 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799         return self->GetConnectionCount();
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Connect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Disconnect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 808           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 809 /*@SWIG@*/ self->Emit( arg );
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 834         self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 837         self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 840         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg1, arg2 );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 850         self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 853         self->Disconnect( func );
 854       }
 855 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 856         return self->Emit( arg1, arg2 );
 857       }
 858 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 859          return self->Empty();
 860       }
 861 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 862         return self->GetConnectionCount();
 863       }
 864 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 865         self->Connect( func );
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 868         self->Disconnect( func );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 871         return self->Emit( arg1, arg2 );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 874          return self->Empty();
 875       }
 876 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 877         return self->GetConnectionCount();
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 880         self->Connect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 883         self->Disconnect( func );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 886         return self->Emit( arg1, arg2 );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 901           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 911           self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 914           self->Disconnect( func );
 915       }
 916 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 917           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 918 /*@SWIG@*/ self->Emit( arg );
 919       }
 920 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 921          return self->Empty();
 922       }
 923 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 924         return self->GetConnectionCount();
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 927           self->Connect( func );
 928       }
 929 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 930           self->Disconnect( func );
 931       }
 932 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 933           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 934 /*@SWIG@*/ self->Emit( arg );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 953          return self->Empty();
 954       }
 955 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 956         return self->GetConnectionCount();
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 959         self->Connect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 962         self->Disconnect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 965         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg1, arg2 );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 969          return self->Empty();
 970       }
 971 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 972         return self->GetConnectionCount();
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 975         self->Connect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 978         self->Disconnect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 981         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg1, arg2 );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 985          return self->Empty();
 986       }
 987 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 988         return self->GetConnectionCount();
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 991         self->Connect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 994         self->Disconnect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 997         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg1, arg2 );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1007           self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1010           self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1013           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1017          return self->Empty();
1018       }
1019 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){
1020         return self->GetConnectionCount();
1021       }
1022 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)){
1023           return self->Connect( func );
1024       }
1025 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)){
1026           self->Disconnect( func );
1027       }
1028 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){
1029           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1031       }
1032
1033 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1034          return self->Empty();
1035       }
1036 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1037         return self->GetConnectionCount();
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1040           self->Connect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1043           self->Disconnect( func );
1044       }
1045 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1046           return self->Emit();
1047       }
1048
1049 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1050         std::vector< unsigned int >* pv = 0;
1051         if (capacity >= 0) {
1052           pv = new std::vector< unsigned int >();
1053           pv->reserve(capacity);
1054        } else {
1055           throw std::out_of_range("capacity");
1056        }
1057        return pv;
1058       }
1059 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1060         if (index>=0 && index<(int)self->size())
1061           return (*self)[index];
1062         else
1063           throw std::out_of_range("index");
1064       }
1065 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1066         if (index>=0 && index<(int)self->size())
1067           return (*self)[index];
1068         else
1069           throw std::out_of_range("index");
1070       }
1071 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1072         if (index>=0 && index<(int)self->size())
1073           (*self)[index] = val;
1074         else
1075           throw std::out_of_range("index");
1076       }
1077 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1078         self->insert(self->end(), values.begin(), values.end());
1079       }
1080 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1081         if (index < 0)
1082           throw std::out_of_range("index");
1083         if (count < 0)
1084           throw std::out_of_range("count");
1085         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1086           throw std::invalid_argument("invalid range");
1087         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1088       }
1089 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1090         if (index>=0 && index<(int)self->size()+1)
1091           self->insert(self->begin()+index, x);
1092         else
1093           throw std::out_of_range("index");
1094       }
1095 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1096         if (index>=0 && index<(int)self->size()+1)
1097           self->insert(self->begin()+index, values.begin(), values.end());
1098         else
1099           throw std::out_of_range("index");
1100       }
1101 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1102         if (index>=0 && index<(int)self->size())
1103           self->erase(self->begin() + index);
1104         else
1105           throw std::out_of_range("index");
1106       }
1107 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1108         if (index < 0)
1109           throw std::out_of_range("index");
1110         if (count < 0)
1111           throw std::out_of_range("count");
1112         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1113           throw std::invalid_argument("invalid range");
1114         self->erase(self->begin()+index, self->begin()+index+count);
1115       }
1116 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1117         if (count < 0)
1118           throw std::out_of_range("count");
1119         return new std::vector< unsigned int >(count, value);
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1122         std::reverse(self->begin(), self->end());
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1132       }
1133 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1134         if (index < 0)
1135           throw std::out_of_range("index");
1136         if (index+values.size() > self->size())
1137           throw std::out_of_range("index");
1138         std::copy(values.begin(), values.end(), self->begin()+index);
1139       }
1140 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1141         return std::find(self->begin(), self->end(), value) != self->end();
1142       }
1143 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1144         int index = -1;
1145         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1146         if (it != self->end())
1147           index = (int)(it - self->begin());
1148         return index;
1149       }
1150 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1151         int index = -1;
1152         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1153         if (rit != self->rend())
1154           index = (int)(self->rend() - 1 - rit);
1155         return index;
1156       }
1157 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1158         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1159         if (it != self->end()) {
1160           self->erase(it);
1161           return true;
1162         }
1163         return false;
1164       }
1165 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){
1166         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1167         if (capacity >= 0) {
1168           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1169           pv->reserve(capacity);
1170        } else {
1171           throw std::out_of_range("capacity");
1172        }
1173        return pv;
1174       }
1175 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){
1176         if (index>=0 && index<(int)self->size())
1177           return (*self)[index];
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 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){
1182         if (index>=0 && index<(int)self->size())
1183           return (*self)[index];
1184         else
1185           throw std::out_of_range("index");
1186       }
1187 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){
1188         if (index>=0 && index<(int)self->size())
1189           (*self)[index] = val;
1190         else
1191           throw std::out_of_range("index");
1192       }
1193 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){
1194         self->insert(self->end(), values.begin(), values.end());
1195       }
1196 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){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (count < 0)
1200           throw std::out_of_range("count");
1201         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1202           throw std::invalid_argument("invalid range");
1203         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1204       }
1205 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){
1206         if (index>=0 && index<(int)self->size()+1)
1207           self->insert(self->begin()+index, x);
1208         else
1209           throw std::out_of_range("index");
1210       }
1211 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){
1212         if (index>=0 && index<(int)self->size()+1)
1213           self->insert(self->begin()+index, values.begin(), values.end());
1214         else
1215           throw std::out_of_range("index");
1216       }
1217 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){
1218         if (index>=0 && index<(int)self->size())
1219           self->erase(self->begin() + index);
1220         else
1221           throw std::out_of_range("index");
1222       }
1223 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){
1224         if (index < 0)
1225           throw std::out_of_range("index");
1226         if (count < 0)
1227           throw std::out_of_range("count");
1228         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1229           throw std::invalid_argument("invalid range");
1230         self->erase(self->begin()+index, self->begin()+index+count);
1231       }
1232 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){
1233         if (count < 0)
1234           throw std::out_of_range("count");
1235         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1236       }
1237 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){
1238         std::reverse(self->begin(), self->end());
1239       }
1240 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){
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         std::reverse(self->begin()+index, self->begin()+index+count);
1248       }
1249 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){
1250         if (index < 0)
1251           throw std::out_of_range("index");
1252         if (index+values.size() > self->size())
1253           throw std::out_of_range("index");
1254         std::copy(values.begin(), values.end(), self->begin()+index);
1255       }
1256 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1257         std::vector< Dali::Actor >* pv = 0;
1258         if (capacity >= 0) {
1259           pv = new std::vector< Dali::Actor >();
1260           pv->reserve(capacity);
1261        } else {
1262           throw std::out_of_range("capacity");
1263        }
1264        return pv;
1265       }
1266 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1267         if (index>=0 && index<(int)self->size())
1268           return (*self)[index];
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1273         if (index>=0 && index<(int)self->size())
1274           return (*self)[index];
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1279         if (index>=0 && index<(int)self->size())
1280           (*self)[index] = val;
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1285         self->insert(self->end(), values.begin(), values.end());
1286       }
1287 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1297         if (index>=0 && index<(int)self->size()+1)
1298           self->insert(self->begin()+index, x);
1299         else
1300           throw std::out_of_range("index");
1301       }
1302 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1303         if (index>=0 && index<(int)self->size()+1)
1304           self->insert(self->begin()+index, values.begin(), values.end());
1305         else
1306           throw std::out_of_range("index");
1307       }
1308 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1309         if (index>=0 && index<(int)self->size())
1310           self->erase(self->begin() + index);
1311         else
1312           throw std::out_of_range("index");
1313       }
1314 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         self->erase(self->begin()+index, self->begin()+index+count);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1324         if (count < 0)
1325           throw std::out_of_range("count");
1326         return new std::vector< Dali::Actor >(count, value);
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1329         std::reverse(self->begin(), self->end());
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1339       }
1340 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1341         if (index < 0)
1342           throw std::out_of_range("index");
1343         if (index+values.size() > self->size())
1344           throw std::out_of_range("index");
1345         std::copy(values.begin(), values.end(), self->begin()+index);
1346       }
1347 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1348          return self->Empty();
1349       }
1350 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1351         return self->GetConnectionCount();
1352       }
1353 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 &)){
1354           self->Connect( func );
1355       }
1356 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 &)){
1357           self->Disconnect( func );
1358       }
1359 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){
1360           return self->Emit( arg );
1361       }
1362 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){
1363          return self->Empty();
1364       }
1365 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){
1366         return self->GetConnectionCount();
1367       }
1368 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)){
1369         self->Connect( func );
1370       }
1371 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)){
1372         self->Disconnect( func );
1373       }
1374 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){
1375         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1376 /*@SWIG@*/ self->Emit( arg1, arg2 );
1377       }
1378 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1379          return self->Empty();
1380       }
1381 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){
1382         return self->GetConnectionCount();
1383       }
1384 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)){
1385         self->Connect( func );
1386       }
1387 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)){
1388         self->Disconnect( func );
1389       }
1390 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){
1391         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1392 /*@SWIG@*/ self->Emit( arg1, arg2 );
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 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)){
1401         self->Connect( func );
1402       }
1403 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)){
1404         self->Disconnect( func );
1405       }
1406 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){
1407         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1408 /*@SWIG@*/ self->Emit( arg1, arg2 );
1409       }
1410 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){
1411          return self->Empty();
1412       }
1413 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){
1414         return self->GetConnectionCount();
1415       }
1416 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)){
1417         self->Connect( func );
1418       }
1419 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)){
1420         self->Disconnect( func );
1421       }
1422 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){
1423         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1424 /*@SWIG@*/ self->Emit( arg1, arg2 );
1425       }
1426 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1427          return self->Empty();
1428       }
1429 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1430         return self->GetConnectionCount();
1431       }
1432 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)){
1433           self->Connect( func );
1434       }
1435 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)){
1436           self->Disconnect( func );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1439           return self->Emit( arg );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448           self->Connect( func );
1449       }
1450 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)){
1451           self->Disconnect( func );
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1454           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg );
1456       }
1457 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){
1458          return self->Empty();
1459       }
1460 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){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464           return self->Connect( func );
1465       }
1466 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)){
1467           self->Disconnect( func );
1468       }
1469 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){
1470           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1486           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg );
1488       }
1489 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){
1490          return self->Empty();
1491       }
1492 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){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           return self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 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){
1502           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1504       }
1505 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){
1506          return self->Empty();
1507       }
1508 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){
1509         return self->GetConnectionCount();
1510       }
1511 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 &)){
1512           self->Connect( func );
1513       }
1514 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 &)){
1515           self->Disconnect( func );
1516       }
1517 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){
1518           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1519 /*@SWIG@*/ self->Emit( arg );
1520       }
1521 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1522          return self->Empty();
1523       }
1524 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){
1525         return self->GetConnectionCount();
1526       }
1527 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 &)){
1528           self->Connect( func );
1529       }
1530 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 &)){
1531           self->Disconnect( func );
1532       }
1533 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){
1534           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1535 /*@SWIG@*/ self->Emit( arg );
1536       }
1537
1538
1539 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){
1540          return self->Empty();
1541       }
1542 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){
1543         return self->GetConnectionCount();
1544       }
1545 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 &)){
1546         self->Connect( func );
1547       }
1548 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 &)){
1549         self->Disconnect( func );
1550       }
1551 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){
1552         return self->Emit( arg1, arg2 );
1553       }
1554 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1555          return self->Empty();
1556       }
1557 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1558         return self->GetConnectionCount();
1559       }
1560 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)){
1561           self->Connect( func );
1562       }
1563 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)){
1564           self->Disconnect( func );
1565       }
1566 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1567           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1568 /*@SWIG@*/ self->Emit( arg );
1569       }
1570 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1571          return self->Empty();
1572       }
1573 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1574         return self->GetConnectionCount();
1575       }
1576 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 &)){
1577           self->Connect( func );
1578       }
1579 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 &)){
1580           self->Disconnect( func );
1581       }
1582 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){
1583           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1584 /*@SWIG@*/ self->Emit( arg );
1585       }
1586 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1587          return self->Empty();
1588       }
1589 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){
1590         return self->GetConnectionCount();
1591       }
1592 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)){
1593         self->Connect( func );
1594       }
1595 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)){
1596         self->Disconnect( func );
1597       }
1598 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){
1599         return self->Emit( arg1, arg2 );
1600       }
1601 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1602          return self->Empty();
1603       }
1604 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){
1605         return self->GetConnectionCount();
1606       }
1607 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)){
1608         self->Connect( func );
1609       }
1610 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)){
1611         self->Disconnect( func );
1612       }
1613 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){
1614         return self->Emit( arg1, arg2 );
1615       }
1616
1617
1618 /* ---------------------------------------------------
1619  * C++ director class methods
1620  * --------------------------------------------------- */
1621
1622 #include "dali_wrap.h"
1623
1624 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1625   swig_init_callbacks();
1626 }
1627
1628 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1629
1630 }
1631
1632
1633 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1634   int jdepth  ;
1635
1636   if (!swig_callbackOnStageConnection) {
1637     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1638     return;
1639   } else {
1640     jdepth = depth;
1641     swig_callbackOnStageConnection(jdepth);
1642   }
1643 }
1644
1645 void SwigDirector_ViewImpl::OnStageDisconnection() {
1646   if (!swig_callbackOnStageDisconnection) {
1647     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1648     return;
1649   } else {
1650     swig_callbackOnStageDisconnection();
1651   }
1652 }
1653
1654 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1655   void * jchild = 0 ;
1656
1657   if (!swig_callbackOnChildAdd) {
1658     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1659     return;
1660   } else {
1661     jchild = (Dali::Actor *) &child;
1662     swig_callbackOnChildAdd(jchild);
1663   }
1664 }
1665
1666 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1667   void * jchild = 0 ;
1668
1669   if (!swig_callbackOnChildRemove) {
1670     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1671     return;
1672   } else {
1673     jchild = (Dali::Actor *) &child;
1674     swig_callbackOnChildRemove(jchild);
1675   }
1676 }
1677
1678 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1679   int jindex  ;
1680   void * jpropertyValue  ;
1681
1682   if (!swig_callbackOnPropertySet) {
1683     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1684     return;
1685   } else {
1686     jindex = index;
1687     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1688     swig_callbackOnPropertySet(jindex, jpropertyValue);
1689   }
1690 }
1691
1692 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1693   void * jtargetSize = 0 ;
1694
1695   if (!swig_callbackOnSizeSet) {
1696     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1697     return;
1698   } else {
1699     jtargetSize = (Dali::Vector3 *) &targetSize;
1700     swig_callbackOnSizeSet(jtargetSize);
1701   }
1702 }
1703
1704 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1705   void * janimation = 0 ;
1706   void * jtargetSize = 0 ;
1707
1708   if (!swig_callbackOnSizeAnimation) {
1709     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1710     return;
1711   } else {
1712     janimation = (Dali::Animation *) &animation;
1713     jtargetSize = (Dali::Vector3 *) &targetSize;
1714     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1715   }
1716 }
1717
1718 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1719   bool c_result = SwigValueInit< bool >() ;
1720   unsigned int jresult = 0 ;
1721   void * jarg0 = 0 ;
1722
1723   if (!swig_callbackOnTouchEvent) {
1724     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1725   } else {
1726     jarg0 = (Dali::TouchEvent *) &event;
1727     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1728     c_result = jresult ? true : false;
1729   }
1730   return c_result;
1731 }
1732
1733 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1734   bool c_result = SwigValueInit< bool >() ;
1735   unsigned int jresult = 0 ;
1736   void * jarg0 = 0 ;
1737
1738   if (!swig_callbackOnHoverEvent) {
1739     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1740   } else {
1741     jarg0 = (Dali::HoverEvent *) &event;
1742     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1743     c_result = jresult ? true : false;
1744   }
1745   return c_result;
1746 }
1747
1748 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1749   bool c_result = SwigValueInit< bool >() ;
1750   unsigned int jresult = 0 ;
1751   void * jarg0 = 0 ;
1752
1753   if (!swig_callbackOnKeyEvent) {
1754     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1755   } else {
1756     jarg0 = (Dali::KeyEvent *) &event;
1757     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1758     c_result = jresult ? true : false;
1759   }
1760   return c_result;
1761 }
1762
1763 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1764   bool c_result = SwigValueInit< bool >() ;
1765   unsigned int jresult = 0 ;
1766   void * jarg0 = 0 ;
1767
1768   if (!swig_callbackOnWheelEvent) {
1769     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1770   } else {
1771     jarg0 = (Dali::WheelEvent *) &event;
1772     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1773     c_result = jresult ? true : false;
1774   }
1775   return c_result;
1776 }
1777
1778 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1779   void * jsize = 0 ;
1780   void * jcontainer = 0 ;
1781
1782   if (!swig_callbackOnRelayout) {
1783     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1784     return;
1785   } else {
1786     jsize = (Dali::Vector2 *) &size;
1787     jcontainer = (Dali::RelayoutContainer *) &container;
1788     swig_callbackOnRelayout(jsize, jcontainer);
1789   }
1790 }
1791
1792 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1793   int jpolicy  ;
1794   int jdimension  ;
1795
1796   if (!swig_callbackOnSetResizePolicy) {
1797     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1798     return;
1799   } else {
1800     jpolicy = (int)policy;
1801     jdimension = (int)dimension;
1802     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1803   }
1804 }
1805
1806 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1807   Dali::Vector3 c_result ;
1808   void * jresult = 0 ;
1809
1810   if (!swig_callbackGetNaturalSize) {
1811     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1812   } else {
1813     jresult = (void *) swig_callbackGetNaturalSize();
1814     if (!jresult) {
1815       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1816       return c_result;
1817     }
1818     c_result = *(Dali::Vector3 *)jresult;
1819   }
1820   return c_result;
1821 }
1822
1823 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1824   float c_result = SwigValueInit< float >() ;
1825   float jresult = 0 ;
1826   void * jchild = 0 ;
1827   int jdimension  ;
1828
1829   if (!swig_callbackCalculateChildSize) {
1830     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1831   } else {
1832     jchild = (Dali::Actor *) &child;
1833     jdimension = (int)dimension;
1834     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1835     c_result = (float)jresult;
1836   }
1837   return c_result;
1838 }
1839
1840 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1841   float c_result = SwigValueInit< float >() ;
1842   float jresult = 0 ;
1843   float jwidth  ;
1844
1845   if (!swig_callbackGetHeightForWidth) {
1846     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1847   } else {
1848     jwidth = width;
1849     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1850     c_result = (float)jresult;
1851   }
1852   return c_result;
1853 }
1854
1855 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1856   float c_result = SwigValueInit< float >() ;
1857   float jresult = 0 ;
1858   float jheight  ;
1859
1860   if (!swig_callbackGetWidthForHeight) {
1861     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1862   } else {
1863     jheight = height;
1864     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1865     c_result = (float)jresult;
1866   }
1867   return c_result;
1868 }
1869
1870 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1871   bool c_result = SwigValueInit< bool >() ;
1872   unsigned int jresult = 0 ;
1873   int jdimension  ;
1874
1875   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1876     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1877   } else {
1878     jdimension = (int)dimension;
1879     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1880     c_result = jresult ? true : false;
1881   }
1882   return c_result;
1883 }
1884
1885 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1886   int jdimension  ;
1887
1888   if (!swig_callbackOnCalculateRelayoutSize) {
1889     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1890     return;
1891   } else {
1892     jdimension = (int)dimension;
1893     swig_callbackOnCalculateRelayoutSize(jdimension);
1894   }
1895 }
1896
1897 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1898   float jsize  ;
1899   int jdimension  ;
1900
1901   if (!swig_callbackOnLayoutNegotiated) {
1902     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1903     return;
1904   } else {
1905     jsize = size;
1906     jdimension = (int)dimension;
1907     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1908   }
1909 }
1910
1911 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1912   return Dali::CustomActorImpl::GetExtension();
1913 }
1914
1915 void SwigDirector_ViewImpl::OnInitialize() {
1916   if (!swig_callbackOnInitialize) {
1917     Dali::Toolkit::Internal::Control::OnInitialize();
1918     return;
1919   } else {
1920     swig_callbackOnInitialize();
1921   }
1922 }
1923
1924 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1925   void * jchild = 0 ;
1926
1927   if (!swig_callbackOnControlChildAdd) {
1928     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1929     return;
1930   } else {
1931     jchild = (Dali::Actor *) &child;
1932     swig_callbackOnControlChildAdd(jchild);
1933   }
1934 }
1935
1936 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1937   void * jchild = 0 ;
1938
1939   if (!swig_callbackOnControlChildRemove) {
1940     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1941     return;
1942   } else {
1943     jchild = (Dali::Actor *) &child;
1944     swig_callbackOnControlChildRemove(jchild);
1945   }
1946 }
1947
1948 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1949   void * jstyleManager  ;
1950   int jchange  ;
1951
1952   if (!swig_callbackOnStyleChange) {
1953     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1954     return;
1955   } else {
1956     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1957     jchange = (int)change;
1958     swig_callbackOnStyleChange(jstyleManager, jchange);
1959   }
1960 }
1961
1962 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1963   bool c_result = SwigValueInit< bool >() ;
1964   unsigned int jresult = 0 ;
1965
1966   if (!swig_callbackOnAccessibilityActivated) {
1967     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1968   } else {
1969     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1970     c_result = jresult ? true : false;
1971   }
1972   return c_result;
1973 }
1974
1975 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1976   bool c_result = SwigValueInit< bool >() ;
1977   unsigned int jresult = 0 ;
1978   void * jgesture  ;
1979
1980   if (!swig_callbackOnAccessibilityPan) {
1981     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1982   } else {
1983     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1984     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1985     c_result = jresult ? true : false;
1986   }
1987   return c_result;
1988 }
1989
1990 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1991   bool c_result = SwigValueInit< bool >() ;
1992   unsigned int jresult = 0 ;
1993   void * jtouchEvent = 0 ;
1994
1995   if (!swig_callbackOnAccessibilityTouch) {
1996     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1997   } else {
1998     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1999     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2000     c_result = jresult ? true : false;
2001   }
2002   return c_result;
2003 }
2004
2005 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2006   bool c_result = SwigValueInit< bool >() ;
2007   unsigned int jresult = 0 ;
2008   unsigned int jisIncrease  ;
2009
2010   if (!swig_callbackOnAccessibilityValueChange) {
2011     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2012   } else {
2013     jisIncrease = isIncrease;
2014     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2015     c_result = jresult ? true : false;
2016   }
2017   return c_result;
2018 }
2019
2020 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2021   bool c_result = SwigValueInit< bool >() ;
2022   unsigned int jresult = 0 ;
2023
2024   if (!swig_callbackOnAccessibilityZoom) {
2025     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2026   } else {
2027     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2028     c_result = jresult ? true : false;
2029   }
2030   return c_result;
2031 }
2032
2033 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2034   if (!swig_callbackOnKeyInputFocusGained) {
2035     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2036     return;
2037   } else {
2038     swig_callbackOnKeyInputFocusGained();
2039   }
2040 }
2041
2042 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2043   if (!swig_callbackOnKeyInputFocusLost) {
2044     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2045     return;
2046   } else {
2047     swig_callbackOnKeyInputFocusLost();
2048   }
2049 }
2050
2051 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2052   Dali::Actor c_result ;
2053   void * jresult = 0 ;
2054   void * jcurrentFocusedActor  ;
2055   int jdirection  ;
2056   unsigned int jloopEnabled  ;
2057
2058   if (!swig_callbackGetNextKeyboardFocusableActor) {
2059     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2060   } else {
2061     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2062     jdirection = (int)direction;
2063     jloopEnabled = loopEnabled;
2064     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2065     if (!jresult) {
2066       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2067       return c_result;
2068     }
2069     c_result = *(Dali::Actor *)jresult;
2070   }
2071   return c_result;
2072 }
2073
2074 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2075   void * jcommitedFocusableActor  ;
2076
2077   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2078     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2079     return;
2080   } else {
2081     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2082     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2083   }
2084 }
2085
2086 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2087   bool c_result = SwigValueInit< bool >() ;
2088   unsigned int jresult = 0 ;
2089
2090   if (!swig_callbackOnKeyboardEnter) {
2091     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2092   } else {
2093     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2094     c_result = jresult ? true : false;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2100   void * jpinch = 0 ;
2101
2102   if (!swig_callbackOnPinch) {
2103     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2104     return;
2105   } else {
2106     jpinch = (Dali::PinchGesture *) &pinch;
2107     swig_callbackOnPinch(jpinch);
2108   }
2109 }
2110
2111 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2112   void * jpan = 0 ;
2113
2114   if (!swig_callbackOnPan) {
2115     Dali::Toolkit::Internal::Control::OnPan(pan);
2116     return;
2117   } else {
2118     jpan = (Dali::PanGesture *) &pan;
2119     swig_callbackOnPan(jpan);
2120   }
2121 }
2122
2123 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2124   void * jtap = 0 ;
2125
2126   if (!swig_callbackOnTap) {
2127     Dali::Toolkit::Internal::Control::OnTap(tap);
2128     return;
2129   } else {
2130     jtap = (Dali::TapGesture *) &tap;
2131     swig_callbackOnTap(jtap);
2132   }
2133 }
2134
2135 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2136   void * jlongPress = 0 ;
2137
2138   if (!swig_callbackOnLongPress) {
2139     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2140     return;
2141   } else {
2142     jlongPress = (Dali::LongPressGesture *) &longPress;
2143     swig_callbackOnLongPress(jlongPress);
2144   }
2145 }
2146
2147 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2148   void * jslotObserver = 0 ;
2149   void * jcallback = 0 ;
2150
2151   if (!swig_callbackSignalConnected) {
2152     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2153     return;
2154   } else {
2155     jslotObserver = (void *) slotObserver;
2156     jcallback = (void *) callback;
2157     swig_callbackSignalConnected(jslotObserver, jcallback);
2158   }
2159 }
2160
2161 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2162   void * jslotObserver = 0 ;
2163   void * jcallback = 0 ;
2164
2165   if (!swig_callbackSignalDisconnected) {
2166     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2167     return;
2168   } else {
2169     jslotObserver = (void *) slotObserver;
2170     jcallback = (void *) callback;
2171     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2172   }
2173 }
2174
2175 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2176   return Dali::Toolkit::Internal::Control::GetControlExtension();
2177 }
2178
2179 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) {
2180   swig_callbackOnStageConnection = callbackOnStageConnection;
2181   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2182   swig_callbackOnChildAdd = callbackOnChildAdd;
2183   swig_callbackOnChildRemove = callbackOnChildRemove;
2184   swig_callbackOnPropertySet = callbackOnPropertySet;
2185   swig_callbackOnSizeSet = callbackOnSizeSet;
2186   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2187   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2188   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2189   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2190   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2191   swig_callbackOnRelayout = callbackOnRelayout;
2192   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2193   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2194   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2195   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2196   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2197   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2198   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2199   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2200   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2201   swig_callbackOnInitialize = callbackOnInitialize;
2202   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2203   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2204   swig_callbackOnStyleChange = callbackOnStyleChange;
2205   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2206   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2207   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2208   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2209   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2210   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2211   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2212   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2213   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2214   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2215   swig_callbackOnPinch = callbackOnPinch;
2216   swig_callbackOnPan = callbackOnPan;
2217   swig_callbackOnTap = callbackOnTap;
2218   swig_callbackOnLongPress = callbackOnLongPress;
2219   swig_callbackSignalConnected = callbackSignalConnected;
2220   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2221 }
2222
2223 void SwigDirector_ViewImpl::swig_init_callbacks() {
2224   swig_callbackOnStageConnection = 0;
2225   swig_callbackOnStageDisconnection = 0;
2226   swig_callbackOnChildAdd = 0;
2227   swig_callbackOnChildRemove = 0;
2228   swig_callbackOnPropertySet = 0;
2229   swig_callbackOnSizeSet = 0;
2230   swig_callbackOnSizeAnimation = 0;
2231   swig_callbackOnTouchEvent = 0;
2232   swig_callbackOnHoverEvent = 0;
2233   swig_callbackOnKeyEvent = 0;
2234   swig_callbackOnWheelEvent = 0;
2235   swig_callbackOnRelayout = 0;
2236   swig_callbackOnSetResizePolicy = 0;
2237   swig_callbackGetNaturalSize = 0;
2238   swig_callbackCalculateChildSize = 0;
2239   swig_callbackGetHeightForWidth = 0;
2240   swig_callbackGetWidthForHeight = 0;
2241   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2242   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2243   swig_callbackOnCalculateRelayoutSize = 0;
2244   swig_callbackOnLayoutNegotiated = 0;
2245   swig_callbackOnInitialize = 0;
2246   swig_callbackOnControlChildAdd = 0;
2247   swig_callbackOnControlChildRemove = 0;
2248   swig_callbackOnStyleChange = 0;
2249   swig_callbackOnAccessibilityActivated = 0;
2250   swig_callbackOnAccessibilityPan = 0;
2251   swig_callbackOnAccessibilityTouch = 0;
2252   swig_callbackOnAccessibilityValueChange = 0;
2253   swig_callbackOnAccessibilityZoom = 0;
2254   swig_callbackOnKeyInputFocusGained = 0;
2255   swig_callbackOnKeyInputFocusLost = 0;
2256   swig_callbackGetNextKeyboardFocusableActor = 0;
2257   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2258   swig_callbackOnKeyboardEnter = 0;
2259   swig_callbackOnPinch = 0;
2260   swig_callbackOnPan = 0;
2261   swig_callbackOnTap = 0;
2262   swig_callbackOnLongPress = 0;
2263   swig_callbackSignalConnected = 0;
2264   swig_callbackSignalDisconnected = 0;
2265 }
2266
2267 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2268   swig_init_callbacks();
2269 }
2270
2271 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2272
2273 }
2274
2275
2276 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2277   unsigned int c_result = SwigValueInit< unsigned int >() ;
2278   unsigned int jresult = 0 ;
2279
2280   if (!swig_callbackGetNumberOfItems) {
2281     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2282   } else {
2283     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2284     c_result = (unsigned int)jresult;
2285   }
2286   return c_result;
2287 }
2288
2289 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2290   Dali::Actor c_result ;
2291   void * jresult = 0 ;
2292   unsigned int jitemId  ;
2293
2294   if (!swig_callbackNewItem) {
2295     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2296   } else {
2297     jitemId = itemId;
2298     jresult = (void *) swig_callbackNewItem(jitemId);
2299     if (!jresult) {
2300       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2301       return c_result;
2302     }
2303     c_result = *(Dali::Actor *)jresult;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2309   unsigned int jitemId  ;
2310   void * jactor  ;
2311
2312   if (!swig_callbackItemReleased) {
2313     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2314     return;
2315   } else {
2316     jitemId = itemId;
2317     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2318     swig_callbackItemReleased(jitemId, jactor);
2319   }
2320 }
2321
2322 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2323   return Dali::Toolkit::ItemFactory::GetExtension();
2324 }
2325
2326 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2327   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2328   swig_callbackNewItem = callbackNewItem;
2329   swig_callbackItemReleased = callbackItemReleased;
2330 }
2331
2332 void SwigDirector_ItemFactory::swig_init_callbacks() {
2333   swig_callbackGetNumberOfItems = 0;
2334   swig_callbackNewItem = 0;
2335   swig_callbackItemReleased = 0;
2336 }
2337
2338 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2339   swig_init_callbacks();
2340 }
2341
2342 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2343
2344 }
2345
2346
2347 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2348   Dali::Actor c_result ;
2349   void * jresult = 0 ;
2350   void * jcurrent  ;
2351   void * jproposed  ;
2352   int jdirection  ;
2353
2354   if (!swig_callbackGetNextFocusableActor) {
2355     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2356   } else {
2357     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2358     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2359     jdirection = (int)direction;
2360     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2361     if (!jresult) {
2362       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2363       return c_result;
2364     }
2365     c_result = *(Dali::Actor *)jresult;
2366   }
2367   return c_result;
2368 }
2369
2370 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2371   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2372 }
2373
2374 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2375   swig_callbackGetNextFocusableActor = 0;
2376 }
2377
2378
2379 #ifdef __cplusplus
2380 extern "C" {
2381 #endif
2382
2383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2384   void * jresult ;
2385   floatp *result = 0 ;
2386
2387   {
2388     try {
2389       result = (floatp *)new_floatp();
2390     } catch (std::out_of_range& e) {
2391       {
2392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2393       };
2394     } catch (std::exception& e) {
2395       {
2396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2397       };
2398     } catch (...) {
2399       {
2400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2401       };
2402     }
2403   }
2404   jresult = (void *)result;
2405   return jresult;
2406 }
2407
2408
2409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2410   floatp *arg1 = (floatp *) 0 ;
2411
2412   arg1 = (floatp *)jarg1;
2413   {
2414     try {
2415       delete_floatp(arg1);
2416     } catch (std::out_of_range& e) {
2417       {
2418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2419       };
2420     } catch (std::exception& e) {
2421       {
2422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2423       };
2424     } catch (...) {
2425       {
2426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2427       };
2428     }
2429   }
2430 }
2431
2432
2433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2434   floatp *arg1 = (floatp *) 0 ;
2435   float arg2 ;
2436
2437   arg1 = (floatp *)jarg1;
2438   arg2 = (float)jarg2;
2439   {
2440     try {
2441       floatp_assign(arg1,arg2);
2442     } catch (std::out_of_range& e) {
2443       {
2444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2445       };
2446     } catch (std::exception& e) {
2447       {
2448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2449       };
2450     } catch (...) {
2451       {
2452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2453       };
2454     }
2455   }
2456 }
2457
2458
2459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2460   float jresult ;
2461   floatp *arg1 = (floatp *) 0 ;
2462   float result;
2463
2464   arg1 = (floatp *)jarg1;
2465   {
2466     try {
2467       result = (float)floatp_value(arg1);
2468     } catch (std::out_of_range& e) {
2469       {
2470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2471       };
2472     } catch (std::exception& e) {
2473       {
2474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2475       };
2476     } catch (...) {
2477       {
2478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2479       };
2480     }
2481   }
2482   jresult = result;
2483   return jresult;
2484 }
2485
2486
2487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2488   void * jresult ;
2489   floatp *arg1 = (floatp *) 0 ;
2490   float *result = 0 ;
2491
2492   arg1 = (floatp *)jarg1;
2493   {
2494     try {
2495       result = (float *)floatp_cast(arg1);
2496     } catch (std::out_of_range& e) {
2497       {
2498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2499       };
2500     } catch (std::exception& e) {
2501       {
2502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2503       };
2504     } catch (...) {
2505       {
2506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2507       };
2508     }
2509   }
2510   jresult = (void *)result;
2511   return jresult;
2512 }
2513
2514
2515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2516   void * jresult ;
2517   float *arg1 = (float *) 0 ;
2518   floatp *result = 0 ;
2519
2520   arg1 = (float *)jarg1;
2521   {
2522     try {
2523       result = (floatp *)floatp_frompointer(arg1);
2524     } catch (std::out_of_range& e) {
2525       {
2526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2527       };
2528     } catch (std::exception& e) {
2529       {
2530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2531       };
2532     } catch (...) {
2533       {
2534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2535       };
2536     }
2537   }
2538   jresult = (void *)result;
2539   return jresult;
2540 }
2541
2542
2543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2544   void * jresult ;
2545   intp *result = 0 ;
2546
2547   {
2548     try {
2549       result = (intp *)new_intp();
2550     } catch (std::out_of_range& e) {
2551       {
2552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2553       };
2554     } catch (std::exception& e) {
2555       {
2556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2557       };
2558     } catch (...) {
2559       {
2560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2561       };
2562     }
2563   }
2564   jresult = (void *)result;
2565   return jresult;
2566 }
2567
2568
2569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2570   intp *arg1 = (intp *) 0 ;
2571
2572   arg1 = (intp *)jarg1;
2573   {
2574     try {
2575       delete_intp(arg1);
2576     } catch (std::out_of_range& e) {
2577       {
2578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2579       };
2580     } catch (std::exception& e) {
2581       {
2582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2583       };
2584     } catch (...) {
2585       {
2586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2587       };
2588     }
2589   }
2590 }
2591
2592
2593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2594   intp *arg1 = (intp *) 0 ;
2595   int arg2 ;
2596
2597   arg1 = (intp *)jarg1;
2598   arg2 = (int)jarg2;
2599   {
2600     try {
2601       intp_assign(arg1,arg2);
2602     } catch (std::out_of_range& e) {
2603       {
2604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2605       };
2606     } catch (std::exception& e) {
2607       {
2608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2609       };
2610     } catch (...) {
2611       {
2612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2613       };
2614     }
2615   }
2616 }
2617
2618
2619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2620   int jresult ;
2621   intp *arg1 = (intp *) 0 ;
2622   int result;
2623
2624   arg1 = (intp *)jarg1;
2625   {
2626     try {
2627       result = (int)intp_value(arg1);
2628     } catch (std::out_of_range& e) {
2629       {
2630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (std::exception& e) {
2633       {
2634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2635       };
2636     } catch (...) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2639       };
2640     }
2641   }
2642   jresult = result;
2643   return jresult;
2644 }
2645
2646
2647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2648   void * jresult ;
2649   intp *arg1 = (intp *) 0 ;
2650   int *result = 0 ;
2651
2652   arg1 = (intp *)jarg1;
2653   {
2654     try {
2655       result = (int *)intp_cast(arg1);
2656     } catch (std::out_of_range& e) {
2657       {
2658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2659       };
2660     } catch (std::exception& e) {
2661       {
2662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2667       };
2668     }
2669   }
2670   jresult = (void *)result;
2671   return jresult;
2672 }
2673
2674
2675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2676   void * jresult ;
2677   int *arg1 = (int *) 0 ;
2678   intp *result = 0 ;
2679
2680   arg1 = (int *)jarg1;
2681   {
2682     try {
2683       result = (intp *)intp_frompointer(arg1);
2684     } catch (std::out_of_range& e) {
2685       {
2686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2687       };
2688     } catch (std::exception& e) {
2689       {
2690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (...) {
2693       {
2694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2695       };
2696     }
2697   }
2698   jresult = (void *)result;
2699   return jresult;
2700 }
2701
2702
2703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2704   void * jresult ;
2705   doublep *result = 0 ;
2706
2707   {
2708     try {
2709       result = (doublep *)new_doublep();
2710     } catch (std::out_of_range& e) {
2711       {
2712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (std::exception& e) {
2715       {
2716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (...) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2721       };
2722     }
2723   }
2724   jresult = (void *)result;
2725   return jresult;
2726 }
2727
2728
2729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2730   doublep *arg1 = (doublep *) 0 ;
2731
2732   arg1 = (doublep *)jarg1;
2733   {
2734     try {
2735       delete_doublep(arg1);
2736     } catch (std::out_of_range& e) {
2737       {
2738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2739       };
2740     } catch (std::exception& e) {
2741       {
2742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2743       };
2744     } catch (...) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2747       };
2748     }
2749   }
2750 }
2751
2752
2753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2754   doublep *arg1 = (doublep *) 0 ;
2755   double arg2 ;
2756
2757   arg1 = (doublep *)jarg1;
2758   arg2 = (double)jarg2;
2759   {
2760     try {
2761       doublep_assign(arg1,arg2);
2762     } catch (std::out_of_range& e) {
2763       {
2764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2765       };
2766     } catch (std::exception& e) {
2767       {
2768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2769       };
2770     } catch (...) {
2771       {
2772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2773       };
2774     }
2775   }
2776 }
2777
2778
2779 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2780   double jresult ;
2781   doublep *arg1 = (doublep *) 0 ;
2782   double result;
2783
2784   arg1 = (doublep *)jarg1;
2785   {
2786     try {
2787       result = (double)doublep_value(arg1);
2788     } catch (std::out_of_range& e) {
2789       {
2790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (std::exception& e) {
2793       {
2794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802   jresult = result;
2803   return jresult;
2804 }
2805
2806
2807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2808   void * jresult ;
2809   doublep *arg1 = (doublep *) 0 ;
2810   double *result = 0 ;
2811
2812   arg1 = (doublep *)jarg1;
2813   {
2814     try {
2815       result = (double *)doublep_cast(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2827       };
2828     }
2829   }
2830   jresult = (void *)result;
2831   return jresult;
2832 }
2833
2834
2835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2836   void * jresult ;
2837   double *arg1 = (double *) 0 ;
2838   doublep *result = 0 ;
2839
2840   arg1 = (double *)jarg1;
2841   {
2842     try {
2843       result = (doublep *)doublep_frompointer(arg1);
2844     } catch (std::out_of_range& e) {
2845       {
2846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2847       };
2848     } catch (std::exception& e) {
2849       {
2850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2851       };
2852     } catch (...) {
2853       {
2854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2855       };
2856     }
2857   }
2858   jresult = (void *)result;
2859   return jresult;
2860 }
2861
2862
2863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2864   void * jresult ;
2865   uintp *result = 0 ;
2866
2867   {
2868     try {
2869       result = (uintp *)new_uintp();
2870     } catch (std::out_of_range& e) {
2871       {
2872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2873       };
2874     } catch (std::exception& e) {
2875       {
2876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2877       };
2878     } catch (...) {
2879       {
2880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2881       };
2882     }
2883   }
2884   jresult = (void *)result;
2885   return jresult;
2886 }
2887
2888
2889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2890   uintp *arg1 = (uintp *) 0 ;
2891
2892   arg1 = (uintp *)jarg1;
2893   {
2894     try {
2895       delete_uintp(arg1);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2903       };
2904     } catch (...) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2907       };
2908     }
2909   }
2910 }
2911
2912
2913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2914   uintp *arg1 = (uintp *) 0 ;
2915   unsigned int arg2 ;
2916
2917   arg1 = (uintp *)jarg1;
2918   arg2 = (unsigned int)jarg2;
2919   {
2920     try {
2921       uintp_assign(arg1,arg2);
2922     } catch (std::out_of_range& e) {
2923       {
2924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2925       };
2926     } catch (std::exception& e) {
2927       {
2928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2929       };
2930     } catch (...) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2933       };
2934     }
2935   }
2936 }
2937
2938
2939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2940   unsigned int jresult ;
2941   uintp *arg1 = (uintp *) 0 ;
2942   unsigned int result;
2943
2944   arg1 = (uintp *)jarg1;
2945   {
2946     try {
2947       result = (unsigned int)uintp_value(arg1);
2948     } catch (std::out_of_range& e) {
2949       {
2950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (std::exception& e) {
2953       {
2954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962   jresult = result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2968   void * jresult ;
2969   uintp *arg1 = (uintp *) 0 ;
2970   unsigned int *result = 0 ;
2971
2972   arg1 = (uintp *)jarg1;
2973   {
2974     try {
2975       result = (unsigned int *)uintp_cast(arg1);
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2987       };
2988     }
2989   }
2990   jresult = (void *)result;
2991   return jresult;
2992 }
2993
2994
2995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2996   void * jresult ;
2997   unsigned int *arg1 = (unsigned int *) 0 ;
2998   uintp *result = 0 ;
2999
3000   arg1 = (unsigned int *)jarg1;
3001   {
3002     try {
3003       result = (uintp *)uintp_frompointer(arg1);
3004     } catch (std::out_of_range& e) {
3005       {
3006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3007       };
3008     } catch (std::exception& e) {
3009       {
3010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3011       };
3012     } catch (...) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3015       };
3016     }
3017   }
3018   jresult = (void *)result;
3019   return jresult;
3020 }
3021
3022
3023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3024   void * jresult ;
3025   ushortp *result = 0 ;
3026
3027   {
3028     try {
3029       result = (ushortp *)new_ushortp();
3030     } catch (std::out_of_range& e) {
3031       {
3032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3033       };
3034     } catch (std::exception& e) {
3035       {
3036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3041       };
3042     }
3043   }
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3050   ushortp *arg1 = (ushortp *) 0 ;
3051
3052   arg1 = (ushortp *)jarg1;
3053   {
3054     try {
3055       delete_ushortp(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3063       };
3064     } catch (...) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3067       };
3068     }
3069   }
3070 }
3071
3072
3073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3074   ushortp *arg1 = (ushortp *) 0 ;
3075   unsigned short arg2 ;
3076
3077   arg1 = (ushortp *)jarg1;
3078   arg2 = (unsigned short)jarg2;
3079   {
3080     try {
3081       ushortp_assign(arg1,arg2);
3082     } catch (std::out_of_range& e) {
3083       {
3084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3085       };
3086     } catch (std::exception& e) {
3087       {
3088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3089       };
3090     } catch (...) {
3091       {
3092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3093       };
3094     }
3095   }
3096 }
3097
3098
3099 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3100   unsigned short jresult ;
3101   ushortp *arg1 = (ushortp *) 0 ;
3102   unsigned short result;
3103
3104   arg1 = (ushortp *)jarg1;
3105   {
3106     try {
3107       result = (unsigned short)ushortp_value(arg1);
3108     } catch (std::out_of_range& e) {
3109       {
3110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (std::exception& e) {
3113       {
3114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3115       };
3116     } catch (...) {
3117       {
3118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3119       };
3120     }
3121   }
3122   jresult = result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3128   void * jresult ;
3129   ushortp *arg1 = (ushortp *) 0 ;
3130   unsigned short *result = 0 ;
3131
3132   arg1 = (ushortp *)jarg1;
3133   {
3134     try {
3135       result = (unsigned short *)ushortp_cast(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3147       };
3148     }
3149   }
3150   jresult = (void *)result;
3151   return jresult;
3152 }
3153
3154
3155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3156   void * jresult ;
3157   unsigned short *arg1 = (unsigned short *) 0 ;
3158   ushortp *result = 0 ;
3159
3160   arg1 = (unsigned short *)jarg1;
3161   {
3162     try {
3163       result = (ushortp *)ushortp_frompointer(arg1);
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (...) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3175       };
3176     }
3177   }
3178   jresult = (void *)result;
3179   return jresult;
3180 }
3181
3182
3183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3184   unsigned int jresult ;
3185   int arg1 ;
3186   unsigned int result;
3187
3188   arg1 = (int)jarg1;
3189   {
3190     try {
3191       result = (unsigned int)int_to_uint(arg1);
3192     } catch (std::out_of_range& e) {
3193       {
3194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3195       };
3196     } catch (std::exception& e) {
3197       {
3198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3199       };
3200     } catch (...) {
3201       {
3202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3203       };
3204     }
3205   }
3206   jresult = result;
3207   return jresult;
3208 }
3209
3210
3211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3212   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3213
3214   arg1 = (Dali::RefObject *)jarg1;
3215   {
3216     try {
3217       (arg1)->Reference();
3218     } catch (std::out_of_range& e) {
3219       {
3220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3221       };
3222     } catch (std::exception& e) {
3223       {
3224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3225       };
3226     } catch (...) {
3227       {
3228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3229       };
3230     }
3231   }
3232 }
3233
3234
3235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3236   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3237
3238   arg1 = (Dali::RefObject *)jarg1;
3239   {
3240     try {
3241       (arg1)->Unreference();
3242     } catch (std::out_of_range& e) {
3243       {
3244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3245       };
3246     } catch (std::exception& e) {
3247       {
3248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3249       };
3250     } catch (...) {
3251       {
3252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3253       };
3254     }
3255   }
3256 }
3257
3258
3259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3260   int jresult ;
3261   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3262   int result;
3263
3264   arg1 = (Dali::RefObject *)jarg1;
3265   {
3266     try {
3267       result = (int)(arg1)->ReferenceCount();
3268     } catch (std::out_of_range& e) {
3269       {
3270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (std::exception& e) {
3273       {
3274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3275       };
3276     } catch (...) {
3277       {
3278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3279       };
3280     }
3281   }
3282   jresult = result;
3283   return jresult;
3284 }
3285
3286
3287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3288   void * jresult ;
3289   Dali::Any *result = 0 ;
3290
3291   {
3292     try {
3293       result = (Dali::Any *)new Dali::Any();
3294     } catch (std::out_of_range& e) {
3295       {
3296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (std::exception& e) {
3299       {
3300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308   jresult = (void *)result;
3309   return jresult;
3310 }
3311
3312
3313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3314   Dali::Any *arg1 = (Dali::Any *) 0 ;
3315
3316   arg1 = (Dali::Any *)jarg1;
3317   {
3318     try {
3319       delete arg1;
3320     } catch (std::out_of_range& e) {
3321       {
3322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3323       };
3324     } catch (std::exception& e) {
3325       {
3326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3327       };
3328     } catch (...) {
3329       {
3330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3331       };
3332     }
3333   }
3334 }
3335
3336
3337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3338   char *arg1 = (char *) 0 ;
3339
3340   arg1 = (char *)jarg1;
3341   {
3342     try {
3343       Dali::Any::AssertAlways((char const *)arg1);
3344     } catch (std::out_of_range& e) {
3345       {
3346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3347       };
3348     } catch (std::exception& e) {
3349       {
3350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3351       };
3352     } catch (...) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3355       };
3356     }
3357   }
3358 }
3359
3360
3361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3362   void * jresult ;
3363   Dali::Any *arg1 = 0 ;
3364   Dali::Any *result = 0 ;
3365
3366   arg1 = (Dali::Any *)jarg1;
3367   if (!arg1) {
3368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3369     return 0;
3370   }
3371   {
3372     try {
3373       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3374     } catch (std::out_of_range& e) {
3375       {
3376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (std::exception& e) {
3379       {
3380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3385       };
3386     }
3387   }
3388   jresult = (void *)result;
3389   return jresult;
3390 }
3391
3392
3393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3394   void * jresult ;
3395   Dali::Any *arg1 = (Dali::Any *) 0 ;
3396   Dali::Any *arg2 = 0 ;
3397   Dali::Any *result = 0 ;
3398
3399   arg1 = (Dali::Any *)jarg1;
3400   arg2 = (Dali::Any *)jarg2;
3401   if (!arg2) {
3402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3403     return 0;
3404   }
3405   {
3406     try {
3407       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3408     } catch (std::out_of_range& e) {
3409       {
3410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3411       };
3412     } catch (std::exception& e) {
3413       {
3414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3415       };
3416     } catch (...) {
3417       {
3418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3419       };
3420     }
3421   }
3422   jresult = (void *)result;
3423   return jresult;
3424 }
3425
3426
3427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3428   void * jresult ;
3429   Dali::Any *arg1 = (Dali::Any *) 0 ;
3430   std::type_info *result = 0 ;
3431
3432   arg1 = (Dali::Any *)jarg1;
3433   {
3434     try {
3435       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3436     } catch (std::out_of_range& e) {
3437       {
3438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (std::exception& e) {
3441       {
3442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3443       };
3444     } catch (...) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3447       };
3448     }
3449   }
3450   jresult = (void *)result;
3451   return jresult;
3452 }
3453
3454
3455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3456   unsigned int jresult ;
3457   Dali::Any *arg1 = (Dali::Any *) 0 ;
3458   bool result;
3459
3460   arg1 = (Dali::Any *)jarg1;
3461   {
3462     try {
3463       result = (bool)((Dali::Any const *)arg1)->Empty();
3464     } catch (std::out_of_range& e) {
3465       {
3466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3467       };
3468     } catch (std::exception& e) {
3469       {
3470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3471       };
3472     } catch (...) {
3473       {
3474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3475       };
3476     }
3477   }
3478   jresult = result;
3479   return jresult;
3480 }
3481
3482
3483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3484   void * jresult ;
3485   std::type_info *arg1 = 0 ;
3486   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3487   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3488   Dali::Any::AnyContainerBase *result = 0 ;
3489
3490   arg1 = (std::type_info *)jarg1;
3491   if (!arg1) {
3492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3493     return 0;
3494   }
3495   arg2 = (Dali::Any::CloneFunc)jarg2;
3496   arg3 = (Dali::Any::DeleteFunc)jarg3;
3497   {
3498     try {
3499       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (...) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3511       };
3512     }
3513   }
3514   jresult = (void *)result;
3515   return jresult;
3516 }
3517
3518
3519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3520   void * jresult ;
3521   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3522   std::type_info *result = 0 ;
3523
3524   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3525   {
3526     try {
3527       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3528     } catch (std::out_of_range& e) {
3529       {
3530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3531       };
3532     } catch (std::exception& e) {
3533       {
3534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3535       };
3536     } catch (...) {
3537       {
3538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3539       };
3540     }
3541   }
3542   jresult = (void *)result;
3543   return jresult;
3544 }
3545
3546
3547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3548   void * jresult ;
3549   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3550   ::std::type_info *result = 0 ;
3551
3552   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3553   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3554   jresult = (void *)result;
3555   return jresult;
3556 }
3557
3558
3559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3560   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3561   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3562
3563   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3564   arg2 = (Dali::Any::CloneFunc)jarg2;
3565   if (arg1) (arg1)->mCloneFunc = arg2;
3566 }
3567
3568
3569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3570   void * jresult ;
3571   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3572   Dali::Any::CloneFunc result;
3573
3574   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3575   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3576   jresult = (void *)result;
3577   return jresult;
3578 }
3579
3580
3581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3582   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3583   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3584
3585   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3586   arg2 = (Dali::Any::DeleteFunc)jarg2;
3587   if (arg1) (arg1)->mDeleteFunc = arg2;
3588 }
3589
3590
3591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3592   void * jresult ;
3593   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3594   Dali::Any::DeleteFunc result;
3595
3596   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3597   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3598   jresult = (void *)result;
3599   return jresult;
3600 }
3601
3602
3603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3604   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3605
3606   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3607   {
3608     try {
3609       delete arg1;
3610     } catch (std::out_of_range& e) {
3611       {
3612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (std::exception& e) {
3615       {
3616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624 }
3625
3626
3627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3628   Dali::Any *arg1 = (Dali::Any *) 0 ;
3629   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3630
3631   arg1 = (Dali::Any *)jarg1;
3632   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3633   if (arg1) (arg1)->mContainer = arg2;
3634 }
3635
3636
3637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3638   void * jresult ;
3639   Dali::Any *arg1 = (Dali::Any *) 0 ;
3640   Dali::Any::AnyContainerBase *result = 0 ;
3641
3642   arg1 = (Dali::Any *)jarg1;
3643   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3644   jresult = (void *)result;
3645   return jresult;
3646 }
3647
3648
3649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3650   char *arg1 = (char *) 0 ;
3651   char *arg2 = (char *) 0 ;
3652
3653   arg1 = (char *)jarg1;
3654   arg2 = (char *)jarg2;
3655   {
3656     try {
3657       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3658     } catch (std::out_of_range& e) {
3659       {
3660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3661       };
3662     } catch (std::exception& e) {
3663       {
3664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3665       };
3666     } catch (...) {
3667       {
3668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3669       };
3670     }
3671   }
3672 }
3673
3674
3675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3676   void * jresult ;
3677   char *arg1 = (char *) 0 ;
3678   char *arg2 = (char *) 0 ;
3679   Dali::DaliException *result = 0 ;
3680
3681   arg1 = (char *)jarg1;
3682   arg2 = (char *)jarg2;
3683   {
3684     try {
3685       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3686     } catch (std::out_of_range& e) {
3687       {
3688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3689       };
3690     } catch (std::exception& e) {
3691       {
3692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3693       };
3694     } catch (...) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3697       };
3698     }
3699   }
3700   jresult = (void *)result;
3701   return jresult;
3702 }
3703
3704
3705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3706   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3707   char *arg2 = (char *) 0 ;
3708
3709   arg1 = (Dali::DaliException *)jarg1;
3710   arg2 = (char *)jarg2;
3711   {
3712     if (arg2) {
3713       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3714       strcpy((char *)arg1->location, (const char *)arg2);
3715     } else {
3716       arg1->location = 0;
3717     }
3718   }
3719 }
3720
3721
3722 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3723   char * jresult ;
3724   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3725   char *result = 0 ;
3726
3727   arg1 = (Dali::DaliException *)jarg1;
3728   result = (char *) ((arg1)->location);
3729   jresult = SWIG_csharp_string_callback((const char *)result);
3730   return jresult;
3731 }
3732
3733
3734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3735   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3736   char *arg2 = (char *) 0 ;
3737
3738   arg1 = (Dali::DaliException *)jarg1;
3739   arg2 = (char *)jarg2;
3740   {
3741     if (arg2) {
3742       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3743       strcpy((char *)arg1->condition, (const char *)arg2);
3744     } else {
3745       arg1->condition = 0;
3746     }
3747   }
3748 }
3749
3750
3751 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3752   char * jresult ;
3753   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3754   char *result = 0 ;
3755
3756   arg1 = (Dali::DaliException *)jarg1;
3757   result = (char *) ((arg1)->condition);
3758   jresult = SWIG_csharp_string_callback((const char *)result);
3759   return jresult;
3760 }
3761
3762
3763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3764   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3765
3766   arg1 = (Dali::DaliException *)jarg1;
3767   {
3768     try {
3769       delete arg1;
3770     } catch (std::out_of_range& e) {
3771       {
3772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3773       };
3774     } catch (std::exception& e) {
3775       {
3776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3781       };
3782     }
3783   }
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3788   void * jresult ;
3789   Dali::Vector2 *result = 0 ;
3790
3791   {
3792     try {
3793       result = (Dali::Vector2 *)new Dali::Vector2();
3794     } catch (std::out_of_range& e) {
3795       {
3796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3797       };
3798     } catch (std::exception& e) {
3799       {
3800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3801       };
3802     } catch (...) {
3803       {
3804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3805       };
3806     }
3807   }
3808   jresult = (void *)result;
3809   return jresult;
3810 }
3811
3812
3813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3814   void * jresult ;
3815   float arg1 ;
3816   float arg2 ;
3817   Dali::Vector2 *result = 0 ;
3818
3819   arg1 = (float)jarg1;
3820   arg2 = (float)jarg2;
3821   {
3822     try {
3823       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3824     } catch (std::out_of_range& e) {
3825       {
3826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3827       };
3828     } catch (std::exception& e) {
3829       {
3830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3831       };
3832     } catch (...) {
3833       {
3834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3835       };
3836     }
3837   }
3838   jresult = (void *)result;
3839   return jresult;
3840 }
3841
3842
3843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3844   void * jresult ;
3845   float *arg1 = (float *) 0 ;
3846   Dali::Vector2 *result = 0 ;
3847
3848   arg1 = jarg1;
3849   {
3850     try {
3851       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3852     } catch (std::out_of_range& e) {
3853       {
3854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3855       };
3856     } catch (std::exception& e) {
3857       {
3858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3859       };
3860     } catch (...) {
3861       {
3862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3863       };
3864     }
3865   }
3866   jresult = (void *)result;
3867
3868
3869   return jresult;
3870 }
3871
3872
3873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3874   void * jresult ;
3875   Dali::Vector3 *arg1 = 0 ;
3876   Dali::Vector2 *result = 0 ;
3877
3878   arg1 = (Dali::Vector3 *)jarg1;
3879   if (!arg1) {
3880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3881     return 0;
3882   }
3883   {
3884     try {
3885       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3886     } catch (std::out_of_range& e) {
3887       {
3888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3889       };
3890     } catch (std::exception& e) {
3891       {
3892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3893       };
3894     } catch (...) {
3895       {
3896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3897       };
3898     }
3899   }
3900   jresult = (void *)result;
3901   return jresult;
3902 }
3903
3904
3905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3906   void * jresult ;
3907   Dali::Vector4 *arg1 = 0 ;
3908   Dali::Vector2 *result = 0 ;
3909
3910   arg1 = (Dali::Vector4 *)jarg1;
3911   if (!arg1) {
3912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3913     return 0;
3914   }
3915   {
3916     try {
3917       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3918     } catch (std::out_of_range& e) {
3919       {
3920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3921       };
3922     } catch (std::exception& e) {
3923       {
3924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3925       };
3926     } catch (...) {
3927       {
3928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3929       };
3930     }
3931   }
3932   jresult = (void *)result;
3933   return jresult;
3934 }
3935
3936
3937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3938   void * jresult ;
3939   Dali::Vector2 *result = 0 ;
3940
3941   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3942   jresult = (void *)result;
3943   return jresult;
3944 }
3945
3946
3947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3948   void * jresult ;
3949   Dali::Vector2 *result = 0 ;
3950
3951   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3952   jresult = (void *)result;
3953   return jresult;
3954 }
3955
3956
3957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3958   void * jresult ;
3959   Dali::Vector2 *result = 0 ;
3960
3961   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3968   void * jresult ;
3969   Dali::Vector2 *result = 0 ;
3970
3971   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3972   jresult = (void *)result;
3973   return jresult;
3974 }
3975
3976
3977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3978   void * jresult ;
3979   Dali::Vector2 *result = 0 ;
3980
3981   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3982   jresult = (void *)result;
3983   return jresult;
3984 }
3985
3986
3987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3988   void * jresult ;
3989   Dali::Vector2 *result = 0 ;
3990
3991   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3992   jresult = (void *)result;
3993   return jresult;
3994 }
3995
3996
3997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3998   void * jresult ;
3999   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4000   float *arg2 = (float *) 0 ;
4001   Dali::Vector2 *result = 0 ;
4002
4003   arg1 = (Dali::Vector2 *)jarg1;
4004   arg2 = jarg2;
4005   {
4006     try {
4007       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4008     } catch (std::out_of_range& e) {
4009       {
4010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4011       };
4012     } catch (std::exception& e) {
4013       {
4014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4015       };
4016     } catch (...) {
4017       {
4018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4019       };
4020     }
4021   }
4022   jresult = (void *)result;
4023
4024
4025   return jresult;
4026 }
4027
4028
4029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4030   void * jresult ;
4031   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4032   Dali::Vector3 *arg2 = 0 ;
4033   Dali::Vector2 *result = 0 ;
4034
4035   arg1 = (Dali::Vector2 *)jarg1;
4036   arg2 = (Dali::Vector3 *)jarg2;
4037   if (!arg2) {
4038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4039     return 0;
4040   }
4041   {
4042     try {
4043       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4044     } catch (std::out_of_range& e) {
4045       {
4046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4047       };
4048     } catch (std::exception& e) {
4049       {
4050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4051       };
4052     } catch (...) {
4053       {
4054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4055       };
4056     }
4057   }
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4064   void * jresult ;
4065   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4066   Dali::Vector4 *arg2 = 0 ;
4067   Dali::Vector2 *result = 0 ;
4068
4069   arg1 = (Dali::Vector2 *)jarg1;
4070   arg2 = (Dali::Vector4 *)jarg2;
4071   if (!arg2) {
4072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4073     return 0;
4074   }
4075   {
4076     try {
4077       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4078     } catch (std::out_of_range& e) {
4079       {
4080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4081       };
4082     } catch (std::exception& e) {
4083       {
4084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4085       };
4086     } catch (...) {
4087       {
4088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4089       };
4090     }
4091   }
4092   jresult = (void *)result;
4093   return jresult;
4094 }
4095
4096
4097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4098   void * jresult ;
4099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4100   Dali::Vector2 *arg2 = 0 ;
4101   Dali::Vector2 result;
4102
4103   arg1 = (Dali::Vector2 *)jarg1;
4104   arg2 = (Dali::Vector2 *)jarg2;
4105   if (!arg2) {
4106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4107     return 0;
4108   }
4109   {
4110     try {
4111       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4112     } catch (std::out_of_range& e) {
4113       {
4114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (std::exception& e) {
4117       {
4118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (...) {
4121       {
4122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4123       };
4124     }
4125   }
4126   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4127   return jresult;
4128 }
4129
4130
4131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4132   void * jresult ;
4133   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4134   Dali::Vector2 *arg2 = 0 ;
4135   Dali::Vector2 *result = 0 ;
4136
4137   arg1 = (Dali::Vector2 *)jarg1;
4138   arg2 = (Dali::Vector2 *)jarg2;
4139   if (!arg2) {
4140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4141     return 0;
4142   }
4143   {
4144     try {
4145       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4146     } catch (std::out_of_range& e) {
4147       {
4148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4149       };
4150     } catch (std::exception& e) {
4151       {
4152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4153       };
4154     } catch (...) {
4155       {
4156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4157       };
4158     }
4159   }
4160   jresult = (void *)result;
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4166   void * jresult ;
4167   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4168   Dali::Vector2 *arg2 = 0 ;
4169   Dali::Vector2 result;
4170
4171   arg1 = (Dali::Vector2 *)jarg1;
4172   arg2 = (Dali::Vector2 *)jarg2;
4173   if (!arg2) {
4174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4175     return 0;
4176   }
4177   {
4178     try {
4179       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4180     } catch (std::out_of_range& e) {
4181       {
4182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4183       };
4184     } catch (std::exception& e) {
4185       {
4186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4187       };
4188     } catch (...) {
4189       {
4190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4191       };
4192     }
4193   }
4194   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4195   return jresult;
4196 }
4197
4198
4199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4200   void * jresult ;
4201   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4202   Dali::Vector2 *arg2 = 0 ;
4203   Dali::Vector2 *result = 0 ;
4204
4205   arg1 = (Dali::Vector2 *)jarg1;
4206   arg2 = (Dali::Vector2 *)jarg2;
4207   if (!arg2) {
4208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4209     return 0;
4210   }
4211   {
4212     try {
4213       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4214     } catch (std::out_of_range& e) {
4215       {
4216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4217       };
4218     } catch (std::exception& e) {
4219       {
4220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4221       };
4222     } catch (...) {
4223       {
4224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4225       };
4226     }
4227   }
4228   jresult = (void *)result;
4229   return jresult;
4230 }
4231
4232
4233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4234   void * jresult ;
4235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4236   Dali::Vector2 *arg2 = 0 ;
4237   Dali::Vector2 result;
4238
4239   arg1 = (Dali::Vector2 *)jarg1;
4240   arg2 = (Dali::Vector2 *)jarg2;
4241   if (!arg2) {
4242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4243     return 0;
4244   }
4245   {
4246     try {
4247       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4248     } catch (std::out_of_range& e) {
4249       {
4250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4251       };
4252     } catch (std::exception& e) {
4253       {
4254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4255       };
4256     } catch (...) {
4257       {
4258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4259       };
4260     }
4261   }
4262   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4263   return jresult;
4264 }
4265
4266
4267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4268   void * jresult ;
4269   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4270   float arg2 ;
4271   Dali::Vector2 result;
4272
4273   arg1 = (Dali::Vector2 *)jarg1;
4274   arg2 = (float)jarg2;
4275   {
4276     try {
4277       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4278     } catch (std::out_of_range& e) {
4279       {
4280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4281       };
4282     } catch (std::exception& e) {
4283       {
4284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4285       };
4286     } catch (...) {
4287       {
4288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4289       };
4290     }
4291   }
4292   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4293   return jresult;
4294 }
4295
4296
4297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4298   void * jresult ;
4299   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4300   Dali::Vector2 *arg2 = 0 ;
4301   Dali::Vector2 *result = 0 ;
4302
4303   arg1 = (Dali::Vector2 *)jarg1;
4304   arg2 = (Dali::Vector2 *)jarg2;
4305   if (!arg2) {
4306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4307     return 0;
4308   }
4309   {
4310     try {
4311       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4312     } catch (std::out_of_range& e) {
4313       {
4314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4315       };
4316     } catch (std::exception& e) {
4317       {
4318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4319       };
4320     } catch (...) {
4321       {
4322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4323       };
4324     }
4325   }
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4332   void * jresult ;
4333   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4334   float arg2 ;
4335   Dali::Vector2 *result = 0 ;
4336
4337   arg1 = (Dali::Vector2 *)jarg1;
4338   arg2 = (float)jarg2;
4339   {
4340     try {
4341       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4342     } catch (std::out_of_range& e) {
4343       {
4344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (std::exception& e) {
4347       {
4348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356   jresult = (void *)result;
4357   return jresult;
4358 }
4359
4360
4361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4362   void * jresult ;
4363   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4364   Dali::Vector2 *arg2 = 0 ;
4365   Dali::Vector2 result;
4366
4367   arg1 = (Dali::Vector2 *)jarg1;
4368   arg2 = (Dali::Vector2 *)jarg2;
4369   if (!arg2) {
4370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4371     return 0;
4372   }
4373   {
4374     try {
4375       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4376     } catch (std::out_of_range& e) {
4377       {
4378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (std::exception& e) {
4381       {
4382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4396   void * jresult ;
4397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4398   float arg2 ;
4399   Dali::Vector2 result;
4400
4401   arg1 = (Dali::Vector2 *)jarg1;
4402   arg2 = (float)jarg2;
4403   {
4404     try {
4405       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4406     } catch (std::out_of_range& e) {
4407       {
4408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4409       };
4410     } catch (std::exception& e) {
4411       {
4412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4413       };
4414     } catch (...) {
4415       {
4416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4417       };
4418     }
4419   }
4420   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4426   void * jresult ;
4427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4428   Dali::Vector2 *arg2 = 0 ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   arg1 = (Dali::Vector2 *)jarg1;
4432   arg2 = (Dali::Vector2 *)jarg2;
4433   if (!arg2) {
4434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4435     return 0;
4436   }
4437   {
4438     try {
4439       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4440     } catch (std::out_of_range& e) {
4441       {
4442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4443       };
4444     } catch (std::exception& e) {
4445       {
4446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4447       };
4448     } catch (...) {
4449       {
4450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4451       };
4452     }
4453   }
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float arg2 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = (float)jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (...) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4481       };
4482     }
4483   }
4484   jresult = (void *)result;
4485   return jresult;
4486 }
4487
4488
4489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4490   void * jresult ;
4491   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4492   Dali::Vector2 result;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   {
4496     try {
4497       result = ((Dali::Vector2 const *)arg1)->operator -();
4498     } catch (std::out_of_range& e) {
4499       {
4500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4501       };
4502     } catch (std::exception& e) {
4503       {
4504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (...) {
4507       {
4508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4509       };
4510     }
4511   }
4512   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4513   return jresult;
4514 }
4515
4516
4517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4518   unsigned int jresult ;
4519   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4520   Dali::Vector2 *arg2 = 0 ;
4521   bool result;
4522
4523   arg1 = (Dali::Vector2 *)jarg1;
4524   arg2 = (Dali::Vector2 *)jarg2;
4525   if (!arg2) {
4526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4527     return 0;
4528   }
4529   {
4530     try {
4531       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4532     } catch (std::out_of_range& e) {
4533       {
4534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4535       };
4536     } catch (std::exception& e) {
4537       {
4538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4539       };
4540     } catch (...) {
4541       {
4542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4543       };
4544     }
4545   }
4546   jresult = result;
4547   return jresult;
4548 }
4549
4550
4551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4552   unsigned int jresult ;
4553   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4554   Dali::Vector2 *arg2 = 0 ;
4555   bool result;
4556
4557   arg1 = (Dali::Vector2 *)jarg1;
4558   arg2 = (Dali::Vector2 *)jarg2;
4559   if (!arg2) {
4560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4561     return 0;
4562   }
4563   {
4564     try {
4565       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4566     } catch (std::out_of_range& e) {
4567       {
4568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4569       };
4570     } catch (std::exception& e) {
4571       {
4572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (...) {
4575       {
4576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4577       };
4578     }
4579   }
4580   jresult = result;
4581   return jresult;
4582 }
4583
4584
4585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4586   float jresult ;
4587   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4588   unsigned int arg2 ;
4589   float *result = 0 ;
4590
4591   arg1 = (Dali::Vector2 *)jarg1;
4592   arg2 = (unsigned int)jarg2;
4593   {
4594     try {
4595       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4596     } catch (std::out_of_range& e) {
4597       {
4598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4599       };
4600     } catch (std::exception& e) {
4601       {
4602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4603       };
4604     } catch (...) {
4605       {
4606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4607       };
4608     }
4609   }
4610   jresult = *result;
4611   return jresult;
4612 }
4613
4614
4615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4616   float jresult ;
4617   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4618   float result;
4619
4620   arg1 = (Dali::Vector2 *)jarg1;
4621   {
4622     try {
4623       result = (float)((Dali::Vector2 const *)arg1)->Length();
4624     } catch (std::out_of_range& e) {
4625       {
4626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (std::exception& e) {
4629       {
4630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638   jresult = result;
4639   return jresult;
4640 }
4641
4642
4643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4644   float jresult ;
4645   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4646   float result;
4647
4648   arg1 = (Dali::Vector2 *)jarg1;
4649   {
4650     try {
4651       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4652     } catch (std::out_of_range& e) {
4653       {
4654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4655       };
4656     } catch (std::exception& e) {
4657       {
4658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4659       };
4660     } catch (...) {
4661       {
4662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4663       };
4664     }
4665   }
4666   jresult = result;
4667   return jresult;
4668 }
4669
4670
4671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4672   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4673
4674   arg1 = (Dali::Vector2 *)jarg1;
4675   {
4676     try {
4677       (arg1)->Normalize();
4678     } catch (std::out_of_range& e) {
4679       {
4680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4681       };
4682     } catch (std::exception& e) {
4683       {
4684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4685       };
4686     } catch (...) {
4687       {
4688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4689       };
4690     }
4691   }
4692 }
4693
4694
4695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4696   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4697   Dali::Vector2 *arg2 = 0 ;
4698   Dali::Vector2 *arg3 = 0 ;
4699
4700   arg1 = (Dali::Vector2 *)jarg1;
4701   arg2 = (Dali::Vector2 *)jarg2;
4702   if (!arg2) {
4703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4704     return ;
4705   }
4706   arg3 = (Dali::Vector2 *)jarg3;
4707   if (!arg3) {
4708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4709     return ;
4710   }
4711   {
4712     try {
4713       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4714     } catch (std::out_of_range& e) {
4715       {
4716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4717       };
4718     } catch (std::exception& e) {
4719       {
4720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4721       };
4722     } catch (...) {
4723       {
4724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4725       };
4726     }
4727   }
4728 }
4729
4730
4731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4732   void * jresult ;
4733   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4734   float *result = 0 ;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   {
4738     try {
4739       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4740     } catch (std::out_of_range& e) {
4741       {
4742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4743       };
4744     } catch (std::exception& e) {
4745       {
4746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (...) {
4749       {
4750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4751       };
4752     }
4753   }
4754   jresult = (void *)result;
4755   return jresult;
4756 }
4757
4758
4759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4760   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4761   float arg2 ;
4762
4763   arg1 = (Dali::Vector2 *)jarg1;
4764   arg2 = (float)jarg2;
4765   if (arg1) (arg1)->x = arg2;
4766 }
4767
4768
4769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4770   float jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float result;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   result = (float) ((arg1)->x);
4776   jresult = result;
4777   return jresult;
4778 }
4779
4780
4781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4782   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4783   float arg2 ;
4784
4785   arg1 = (Dali::Vector2 *)jarg1;
4786   arg2 = (float)jarg2;
4787   if (arg1) (arg1)->width = arg2;
4788 }
4789
4790
4791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4792   float jresult ;
4793   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4794   float result;
4795
4796   arg1 = (Dali::Vector2 *)jarg1;
4797   result = (float) ((arg1)->width);
4798   jresult = result;
4799   return jresult;
4800 }
4801
4802
4803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   float arg2 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (float)jarg2;
4809   if (arg1) (arg1)->y = arg2;
4810 }
4811
4812
4813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4814   float jresult ;
4815   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4816   float result;
4817
4818   arg1 = (Dali::Vector2 *)jarg1;
4819   result = (float) ((arg1)->y);
4820   jresult = result;
4821   return jresult;
4822 }
4823
4824
4825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4826   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4827   float arg2 ;
4828
4829   arg1 = (Dali::Vector2 *)jarg1;
4830   arg2 = (float)jarg2;
4831   if (arg1) (arg1)->height = arg2;
4832 }
4833
4834
4835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4836   float jresult ;
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float result;
4839
4840   arg1 = (Dali::Vector2 *)jarg1;
4841   result = (float) ((arg1)->height);
4842   jresult = result;
4843   return jresult;
4844 }
4845
4846
4847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4848   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4849
4850   arg1 = (Dali::Vector2 *)jarg1;
4851   {
4852     try {
4853       delete arg1;
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4861       };
4862     } catch (...) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4865       };
4866     }
4867   }
4868 }
4869
4870
4871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4872   void * jresult ;
4873   Dali::Vector2 *arg1 = 0 ;
4874   Dali::Vector2 *arg2 = 0 ;
4875   Dali::Vector2 result;
4876
4877   arg1 = (Dali::Vector2 *)jarg1;
4878   if (!arg1) {
4879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4880     return 0;
4881   }
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (...) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4901       };
4902     }
4903   }
4904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4905   return jresult;
4906 }
4907
4908
4909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4910   void * jresult ;
4911   Dali::Vector2 *arg1 = 0 ;
4912   Dali::Vector2 *arg2 = 0 ;
4913   Dali::Vector2 result;
4914
4915   arg1 = (Dali::Vector2 *)jarg1;
4916   if (!arg1) {
4917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4918     return 0;
4919   }
4920   arg2 = (Dali::Vector2 *)jarg2;
4921   if (!arg2) {
4922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4923     return 0;
4924   }
4925   {
4926     try {
4927       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (...) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4939       };
4940     }
4941   }
4942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4948   void * jresult ;
4949   Dali::Vector2 *arg1 = 0 ;
4950   float *arg2 = 0 ;
4951   float *arg3 = 0 ;
4952   float temp2 ;
4953   float temp3 ;
4954   Dali::Vector2 result;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   if (!arg1) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   temp2 = (float)jarg2;
4962   arg2 = &temp2;
4963   temp3 = (float)jarg3;
4964   arg3 = &temp3;
4965   {
4966     try {
4967       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4968     } catch (std::out_of_range& e) {
4969       {
4970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (std::exception& e) {
4973       {
4974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4983   return jresult;
4984 }
4985
4986
4987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4988   void * jresult ;
4989   Dali::Vector3 *result = 0 ;
4990
4991   {
4992     try {
4993       result = (Dali::Vector3 *)new Dali::Vector3();
4994     } catch (std::out_of_range& e) {
4995       {
4996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (std::exception& e) {
4999       {
5000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (...) {
5003       {
5004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5005       };
5006     }
5007   }
5008   jresult = (void *)result;
5009   return jresult;
5010 }
5011
5012
5013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5014   void * jresult ;
5015   float arg1 ;
5016   float arg2 ;
5017   float arg3 ;
5018   Dali::Vector3 *result = 0 ;
5019
5020   arg1 = (float)jarg1;
5021   arg2 = (float)jarg2;
5022   arg3 = (float)jarg3;
5023   {
5024     try {
5025       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5026     } catch (std::out_of_range& e) {
5027       {
5028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (std::exception& e) {
5031       {
5032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (...) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5037       };
5038     }
5039   }
5040   jresult = (void *)result;
5041   return jresult;
5042 }
5043
5044
5045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5046   void * jresult ;
5047   float *arg1 = (float *) 0 ;
5048   Dali::Vector3 *result = 0 ;
5049
5050   arg1 = jarg1;
5051   {
5052     try {
5053       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5054     } catch (std::out_of_range& e) {
5055       {
5056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5057       };
5058     } catch (std::exception& e) {
5059       {
5060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5061       };
5062     } catch (...) {
5063       {
5064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5065       };
5066     }
5067   }
5068   jresult = (void *)result;
5069
5070
5071   return jresult;
5072 }
5073
5074
5075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5076   void * jresult ;
5077   Dali::Vector2 *arg1 = 0 ;
5078   Dali::Vector3 *result = 0 ;
5079
5080   arg1 = (Dali::Vector2 *)jarg1;
5081   if (!arg1) {
5082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5083     return 0;
5084   }
5085   {
5086     try {
5087       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5088     } catch (std::out_of_range& e) {
5089       {
5090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5091       };
5092     } catch (std::exception& e) {
5093       {
5094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5095       };
5096     } catch (...) {
5097       {
5098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5099       };
5100     }
5101   }
5102   jresult = (void *)result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5108   void * jresult ;
5109   Dali::Vector4 *arg1 = 0 ;
5110   Dali::Vector3 *result = 0 ;
5111
5112   arg1 = (Dali::Vector4 *)jarg1;
5113   if (!arg1) {
5114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5115     return 0;
5116   }
5117   {
5118     try {
5119       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5120     } catch (std::out_of_range& e) {
5121       {
5122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5123       };
5124     } catch (std::exception& e) {
5125       {
5126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5127       };
5128     } catch (...) {
5129       {
5130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5131       };
5132     }
5133   }
5134   jresult = (void *)result;
5135   return jresult;
5136 }
5137
5138
5139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5140   void * jresult ;
5141   Dali::Vector3 *result = 0 ;
5142
5143   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5144   jresult = (void *)result;
5145   return jresult;
5146 }
5147
5148
5149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5150   void * jresult ;
5151   Dali::Vector3 *result = 0 ;
5152
5153   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5154   jresult = (void *)result;
5155   return jresult;
5156 }
5157
5158
5159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5160   void * jresult ;
5161   Dali::Vector3 *result = 0 ;
5162
5163   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5164   jresult = (void *)result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5170   void * jresult ;
5171   Dali::Vector3 *result = 0 ;
5172
5173   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5174   jresult = (void *)result;
5175   return jresult;
5176 }
5177
5178
5179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5180   void * jresult ;
5181   Dali::Vector3 *result = 0 ;
5182
5183   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5184   jresult = (void *)result;
5185   return jresult;
5186 }
5187
5188
5189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5190   void * jresult ;
5191   Dali::Vector3 *result = 0 ;
5192
5193   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5194   jresult = (void *)result;
5195   return jresult;
5196 }
5197
5198
5199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5200   void * jresult ;
5201   Dali::Vector3 *result = 0 ;
5202
5203   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5204   jresult = (void *)result;
5205   return jresult;
5206 }
5207
5208
5209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5210   void * jresult ;
5211   Dali::Vector3 *result = 0 ;
5212
5213   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5214   jresult = (void *)result;
5215   return jresult;
5216 }
5217
5218
5219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5220   void * jresult ;
5221   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5222   float *arg2 = (float *) 0 ;
5223   Dali::Vector3 *result = 0 ;
5224
5225   arg1 = (Dali::Vector3 *)jarg1;
5226   arg2 = jarg2;
5227   {
5228     try {
5229       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5230     } catch (std::out_of_range& e) {
5231       {
5232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5233       };
5234     } catch (std::exception& e) {
5235       {
5236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5237       };
5238     } catch (...) {
5239       {
5240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5241       };
5242     }
5243   }
5244   jresult = (void *)result;
5245
5246
5247   return jresult;
5248 }
5249
5250
5251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5252   void * jresult ;
5253   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5254   Dali::Vector2 *arg2 = 0 ;
5255   Dali::Vector3 *result = 0 ;
5256
5257   arg1 = (Dali::Vector3 *)jarg1;
5258   arg2 = (Dali::Vector2 *)jarg2;
5259   if (!arg2) {
5260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5261     return 0;
5262   }
5263   {
5264     try {
5265       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5266     } catch (std::out_of_range& e) {
5267       {
5268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5269       };
5270     } catch (std::exception& e) {
5271       {
5272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5273       };
5274     } catch (...) {
5275       {
5276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5277       };
5278     }
5279   }
5280   jresult = (void *)result;
5281   return jresult;
5282 }
5283
5284
5285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5286   void * jresult ;
5287   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5288   Dali::Vector4 *arg2 = 0 ;
5289   Dali::Vector3 *result = 0 ;
5290
5291   arg1 = (Dali::Vector3 *)jarg1;
5292   arg2 = (Dali::Vector4 *)jarg2;
5293   if (!arg2) {
5294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5295     return 0;
5296   }
5297   {
5298     try {
5299       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5300     } catch (std::out_of_range& e) {
5301       {
5302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5303       };
5304     } catch (std::exception& e) {
5305       {
5306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5307       };
5308     } catch (...) {
5309       {
5310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5311       };
5312     }
5313   }
5314   jresult = (void *)result;
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5320   void * jresult ;
5321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5322   Dali::Vector3 *arg2 = 0 ;
5323   Dali::Vector3 result;
5324
5325   arg1 = (Dali::Vector3 *)jarg1;
5326   arg2 = (Dali::Vector3 *)jarg2;
5327   if (!arg2) {
5328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5329     return 0;
5330   }
5331   {
5332     try {
5333       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5334     } catch (std::out_of_range& e) {
5335       {
5336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (std::exception& e) {
5339       {
5340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5341       };
5342     } catch (...) {
5343       {
5344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5345       };
5346     }
5347   }
5348   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5349   return jresult;
5350 }
5351
5352
5353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5354   void * jresult ;
5355   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5356   Dali::Vector3 *arg2 = 0 ;
5357   Dali::Vector3 *result = 0 ;
5358
5359   arg1 = (Dali::Vector3 *)jarg1;
5360   arg2 = (Dali::Vector3 *)jarg2;
5361   if (!arg2) {
5362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5363     return 0;
5364   }
5365   {
5366     try {
5367       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5368     } catch (std::out_of_range& e) {
5369       {
5370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5371       };
5372     } catch (std::exception& e) {
5373       {
5374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5375       };
5376     } catch (...) {
5377       {
5378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5379       };
5380     }
5381   }
5382   jresult = (void *)result;
5383   return jresult;
5384 }
5385
5386
5387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5388   void * jresult ;
5389   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5390   Dali::Vector3 *arg2 = 0 ;
5391   Dali::Vector3 result;
5392
5393   arg1 = (Dali::Vector3 *)jarg1;
5394   arg2 = (Dali::Vector3 *)jarg2;
5395   if (!arg2) {
5396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5397     return 0;
5398   }
5399   {
5400     try {
5401       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5402     } catch (std::out_of_range& e) {
5403       {
5404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5405       };
5406     } catch (std::exception& e) {
5407       {
5408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5409       };
5410     } catch (...) {
5411       {
5412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5413       };
5414     }
5415   }
5416   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5417   return jresult;
5418 }
5419
5420
5421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5422   void * jresult ;
5423   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5424   Dali::Vector3 *arg2 = 0 ;
5425   Dali::Vector3 *result = 0 ;
5426
5427   arg1 = (Dali::Vector3 *)jarg1;
5428   arg2 = (Dali::Vector3 *)jarg2;
5429   if (!arg2) {
5430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5431     return 0;
5432   }
5433   {
5434     try {
5435       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5443       };
5444     } catch (...) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5447       };
5448     }
5449   }
5450   jresult = (void *)result;
5451   return jresult;
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5458   Dali::Vector3 *arg2 = 0 ;
5459   Dali::Vector3 result;
5460
5461   arg1 = (Dali::Vector3 *)jarg1;
5462   arg2 = (Dali::Vector3 *)jarg2;
5463   if (!arg2) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5465     return 0;
5466   }
5467   {
5468     try {
5469       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5470     } catch (std::out_of_range& e) {
5471       {
5472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5473       };
5474     } catch (std::exception& e) {
5475       {
5476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (...) {
5479       {
5480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5481       };
5482     }
5483   }
5484   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5485   return jresult;
5486 }
5487
5488
5489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5490   void * jresult ;
5491   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5492   float arg2 ;
5493   Dali::Vector3 result;
5494
5495   arg1 = (Dali::Vector3 *)jarg1;
5496   arg2 = (float)jarg2;
5497   {
5498     try {
5499       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5500     } catch (std::out_of_range& e) {
5501       {
5502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5503       };
5504     } catch (std::exception& e) {
5505       {
5506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5507       };
5508     } catch (...) {
5509       {
5510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5511       };
5512     }
5513   }
5514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5515   return jresult;
5516 }
5517
5518
5519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5520   void * jresult ;
5521   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5522   Dali::Vector3 *arg2 = 0 ;
5523   Dali::Vector3 *result = 0 ;
5524
5525   arg1 = (Dali::Vector3 *)jarg1;
5526   arg2 = (Dali::Vector3 *)jarg2;
5527   if (!arg2) {
5528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5529     return 0;
5530   }
5531   {
5532     try {
5533       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5534     } catch (std::out_of_range& e) {
5535       {
5536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5537       };
5538     } catch (std::exception& e) {
5539       {
5540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5541       };
5542     } catch (...) {
5543       {
5544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5545       };
5546     }
5547   }
5548   jresult = (void *)result;
5549   return jresult;
5550 }
5551
5552
5553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5554   void * jresult ;
5555   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5556   float arg2 ;
5557   Dali::Vector3 *result = 0 ;
5558
5559   arg1 = (Dali::Vector3 *)jarg1;
5560   arg2 = (float)jarg2;
5561   {
5562     try {
5563       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5564     } catch (std::out_of_range& e) {
5565       {
5566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5567       };
5568     } catch (std::exception& e) {
5569       {
5570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5571       };
5572     } catch (...) {
5573       {
5574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5575       };
5576     }
5577   }
5578   jresult = (void *)result;
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5584   void * jresult ;
5585   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5586   Dali::Quaternion *arg2 = 0 ;
5587   Dali::Vector3 *result = 0 ;
5588
5589   arg1 = (Dali::Vector3 *)jarg1;
5590   arg2 = (Dali::Quaternion *)jarg2;
5591   if (!arg2) {
5592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5593     return 0;
5594   }
5595   {
5596     try {
5597       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5598     } catch (std::out_of_range& e) {
5599       {
5600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (std::exception& e) {
5603       {
5604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5618   void * jresult ;
5619   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5620   Dali::Vector3 *arg2 = 0 ;
5621   Dali::Vector3 result;
5622
5623   arg1 = (Dali::Vector3 *)jarg1;
5624   arg2 = (Dali::Vector3 *)jarg2;
5625   if (!arg2) {
5626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5627     return 0;
5628   }
5629   {
5630     try {
5631       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5632     } catch (std::out_of_range& e) {
5633       {
5634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (std::exception& e) {
5637       {
5638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5639       };
5640     } catch (...) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5643       };
5644     }
5645   }
5646   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5652   void * jresult ;
5653   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5654   float arg2 ;
5655   Dali::Vector3 result;
5656
5657   arg1 = (Dali::Vector3 *)jarg1;
5658   arg2 = (float)jarg2;
5659   {
5660     try {
5661       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5662     } catch (std::out_of_range& e) {
5663       {
5664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (std::exception& e) {
5667       {
5668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5677   return jresult;
5678 }
5679
5680
5681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5682   void * jresult ;
5683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5684   Dali::Vector3 *arg2 = 0 ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   arg1 = (Dali::Vector3 *)jarg1;
5688   arg2 = (Dali::Vector3 *)jarg2;
5689   if (!arg2) {
5690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5691     return 0;
5692   }
5693   {
5694     try {
5695       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5696     } catch (std::out_of_range& e) {
5697       {
5698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (std::exception& e) {
5701       {
5702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710   jresult = (void *)result;
5711   return jresult;
5712 }
5713
5714
5715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5716   void * jresult ;
5717   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5718   float arg2 ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   arg1 = (Dali::Vector3 *)jarg1;
5722   arg2 = (float)jarg2;
5723   {
5724     try {
5725       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5726     } catch (std::out_of_range& e) {
5727       {
5728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5729       };
5730     } catch (std::exception& e) {
5731       {
5732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5733       };
5734     } catch (...) {
5735       {
5736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5737       };
5738     }
5739   }
5740   jresult = (void *)result;
5741   return jresult;
5742 }
5743
5744
5745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5746   void * jresult ;
5747   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5748   Dali::Vector3 result;
5749
5750   arg1 = (Dali::Vector3 *)jarg1;
5751   {
5752     try {
5753       result = ((Dali::Vector3 const *)arg1)->operator -();
5754     } catch (std::out_of_range& e) {
5755       {
5756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5757       };
5758     } catch (std::exception& e) {
5759       {
5760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5761       };
5762     } catch (...) {
5763       {
5764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5765       };
5766     }
5767   }
5768   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5774   unsigned int jresult ;
5775   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5776   Dali::Vector3 *arg2 = 0 ;
5777   bool result;
5778
5779   arg1 = (Dali::Vector3 *)jarg1;
5780   arg2 = (Dali::Vector3 *)jarg2;
5781   if (!arg2) {
5782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5783     return 0;
5784   }
5785   {
5786     try {
5787       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5788     } catch (std::out_of_range& e) {
5789       {
5790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5791       };
5792     } catch (std::exception& e) {
5793       {
5794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5795       };
5796     } catch (...) {
5797       {
5798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5799       };
5800     }
5801   }
5802   jresult = result;
5803   return jresult;
5804 }
5805
5806
5807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5808   unsigned int jresult ;
5809   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5810   Dali::Vector3 *arg2 = 0 ;
5811   bool result;
5812
5813   arg1 = (Dali::Vector3 *)jarg1;
5814   arg2 = (Dali::Vector3 *)jarg2;
5815   if (!arg2) {
5816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5817     return 0;
5818   }
5819   {
5820     try {
5821       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5822     } catch (std::out_of_range& e) {
5823       {
5824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5825       };
5826     } catch (std::exception& e) {
5827       {
5828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5829       };
5830     } catch (...) {
5831       {
5832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5833       };
5834     }
5835   }
5836   jresult = result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5842   float jresult ;
5843   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5844   unsigned int arg2 ;
5845   float *result = 0 ;
5846
5847   arg1 = (Dali::Vector3 *)jarg1;
5848   arg2 = (unsigned int)jarg2;
5849   {
5850     try {
5851       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5852     } catch (std::out_of_range& e) {
5853       {
5854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (std::exception& e) {
5857       {
5858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (...) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5863       };
5864     }
5865   }
5866   jresult = *result;
5867   return jresult;
5868 }
5869
5870
5871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5872   float jresult ;
5873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5874   Dali::Vector3 *arg2 = 0 ;
5875   float result;
5876
5877   arg1 = (Dali::Vector3 *)jarg1;
5878   arg2 = (Dali::Vector3 *)jarg2;
5879   if (!arg2) {
5880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5881     return 0;
5882   }
5883   {
5884     try {
5885       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5886     } catch (std::out_of_range& e) {
5887       {
5888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (std::exception& e) {
5891       {
5892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (...) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5897       };
5898     }
5899   }
5900   jresult = result;
5901   return jresult;
5902 }
5903
5904
5905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5906   void * jresult ;
5907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5908   Dali::Vector3 *arg2 = 0 ;
5909   Dali::Vector3 result;
5910
5911   arg1 = (Dali::Vector3 *)jarg1;
5912   arg2 = (Dali::Vector3 *)jarg2;
5913   if (!arg2) {
5914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5915     return 0;
5916   }
5917   {
5918     try {
5919       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5920     } catch (std::out_of_range& e) {
5921       {
5922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5923       };
5924     } catch (std::exception& e) {
5925       {
5926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5927       };
5928     } catch (...) {
5929       {
5930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5931       };
5932     }
5933   }
5934   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5935   return jresult;
5936 }
5937
5938
5939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5940   float jresult ;
5941   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5942   float result;
5943
5944   arg1 = (Dali::Vector3 *)jarg1;
5945   {
5946     try {
5947       result = (float)((Dali::Vector3 const *)arg1)->Length();
5948     } catch (std::out_of_range& e) {
5949       {
5950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5951       };
5952     } catch (std::exception& e) {
5953       {
5954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (...) {
5957       {
5958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5959       };
5960     }
5961   }
5962   jresult = result;
5963   return jresult;
5964 }
5965
5966
5967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5968   float jresult ;
5969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5970   float result;
5971
5972   arg1 = (Dali::Vector3 *)jarg1;
5973   {
5974     try {
5975       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (...) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5987       };
5988     }
5989   }
5990   jresult = result;
5991   return jresult;
5992 }
5993
5994
5995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   {
6000     try {
6001       (arg1)->Normalize();
6002     } catch (std::out_of_range& e) {
6003       {
6004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6005       };
6006     } catch (std::exception& e) {
6007       {
6008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6009       };
6010     } catch (...) {
6011       {
6012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6013       };
6014     }
6015   }
6016 }
6017
6018
6019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6021   Dali::Vector3 *arg2 = 0 ;
6022   Dali::Vector3 *arg3 = 0 ;
6023
6024   arg1 = (Dali::Vector3 *)jarg1;
6025   arg2 = (Dali::Vector3 *)jarg2;
6026   if (!arg2) {
6027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6028     return ;
6029   }
6030   arg3 = (Dali::Vector3 *)jarg3;
6031   if (!arg3) {
6032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6033     return ;
6034   }
6035   {
6036     try {
6037       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6045       };
6046     } catch (...) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6049       };
6050     }
6051   }
6052 }
6053
6054
6055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6056   void * jresult ;
6057   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6058   float *result = 0 ;
6059
6060   arg1 = (Dali::Vector3 *)jarg1;
6061   {
6062     try {
6063       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6064     } catch (std::out_of_range& e) {
6065       {
6066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6067       };
6068     } catch (std::exception& e) {
6069       {
6070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6071       };
6072     } catch (...) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6075       };
6076     }
6077   }
6078   jresult = (void *)result;
6079   return jresult;
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6084   void * jresult ;
6085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6086   Dali::Vector2 *result = 0 ;
6087
6088   arg1 = (Dali::Vector3 *)jarg1;
6089   {
6090     try {
6091       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6092     } catch (std::out_of_range& e) {
6093       {
6094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6095       };
6096     } catch (std::exception& e) {
6097       {
6098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6099       };
6100     } catch (...) {
6101       {
6102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6103       };
6104     }
6105   }
6106   jresult = (void *)result;
6107   return jresult;
6108 }
6109
6110
6111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6112   void * jresult ;
6113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6114   Dali::Vector2 *result = 0 ;
6115
6116   arg1 = (Dali::Vector3 *)jarg1;
6117   {
6118     try {
6119       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6120     } catch (std::out_of_range& e) {
6121       {
6122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (std::exception& e) {
6125       {
6126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (...) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6131       };
6132     }
6133   }
6134   jresult = (void *)result;
6135   return jresult;
6136 }
6137
6138
6139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6140   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6141   float arg2 ;
6142
6143   arg1 = (Dali::Vector3 *)jarg1;
6144   arg2 = (float)jarg2;
6145   if (arg1) (arg1)->x = arg2;
6146 }
6147
6148
6149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6150   float jresult ;
6151   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6152   float result;
6153
6154   arg1 = (Dali::Vector3 *)jarg1;
6155   result = (float) ((arg1)->x);
6156   jresult = result;
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6162   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6163   float arg2 ;
6164
6165   arg1 = (Dali::Vector3 *)jarg1;
6166   arg2 = (float)jarg2;
6167   if (arg1) (arg1)->width = arg2;
6168 }
6169
6170
6171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6172   float jresult ;
6173   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6174   float result;
6175
6176   arg1 = (Dali::Vector3 *)jarg1;
6177   result = (float) ((arg1)->width);
6178   jresult = result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6184   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6185   float arg2 ;
6186
6187   arg1 = (Dali::Vector3 *)jarg1;
6188   arg2 = (float)jarg2;
6189   if (arg1) (arg1)->r = arg2;
6190 }
6191
6192
6193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6194   float jresult ;
6195   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6196   float result;
6197
6198   arg1 = (Dali::Vector3 *)jarg1;
6199   result = (float) ((arg1)->r);
6200   jresult = result;
6201   return jresult;
6202 }
6203
6204
6205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6206   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6207   float arg2 ;
6208
6209   arg1 = (Dali::Vector3 *)jarg1;
6210   arg2 = (float)jarg2;
6211   if (arg1) (arg1)->y = arg2;
6212 }
6213
6214
6215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6216   float jresult ;
6217   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6218   float result;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   result = (float) ((arg1)->y);
6222   jresult = result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6228   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6229   float arg2 ;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   arg2 = (float)jarg2;
6233   if (arg1) (arg1)->height = arg2;
6234 }
6235
6236
6237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6238   float jresult ;
6239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6240   float result;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   result = (float) ((arg1)->height);
6244   jresult = result;
6245   return jresult;
6246 }
6247
6248
6249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6251   float arg2 ;
6252
6253   arg1 = (Dali::Vector3 *)jarg1;
6254   arg2 = (float)jarg2;
6255   if (arg1) (arg1)->g = arg2;
6256 }
6257
6258
6259 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6260   float jresult ;
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   float result;
6263
6264   arg1 = (Dali::Vector3 *)jarg1;
6265   result = (float) ((arg1)->g);
6266   jresult = result;
6267   return jresult;
6268 }
6269
6270
6271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   float arg2 ;
6274
6275   arg1 = (Dali::Vector3 *)jarg1;
6276   arg2 = (float)jarg2;
6277   if (arg1) (arg1)->z = arg2;
6278 }
6279
6280
6281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6282   float jresult ;
6283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6284   float result;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   result = (float) ((arg1)->z);
6288   jresult = result;
6289   return jresult;
6290 }
6291
6292
6293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float arg2 ;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   arg2 = (float)jarg2;
6299   if (arg1) (arg1)->depth = arg2;
6300 }
6301
6302
6303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6304   float jresult ;
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   float result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   result = (float) ((arg1)->depth);
6310   jresult = result;
6311   return jresult;
6312 }
6313
6314
6315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6317   float arg2 ;
6318
6319   arg1 = (Dali::Vector3 *)jarg1;
6320   arg2 = (float)jarg2;
6321   if (arg1) (arg1)->b = arg2;
6322 }
6323
6324
6325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6326   float jresult ;
6327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6328   float result;
6329
6330   arg1 = (Dali::Vector3 *)jarg1;
6331   result = (float) ((arg1)->b);
6332   jresult = result;
6333   return jresult;
6334 }
6335
6336
6337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6339
6340   arg1 = (Dali::Vector3 *)jarg1;
6341   {
6342     try {
6343       delete arg1;
6344     } catch (std::out_of_range& e) {
6345       {
6346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6347       };
6348     } catch (std::exception& e) {
6349       {
6350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6351       };
6352     } catch (...) {
6353       {
6354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6355       };
6356     }
6357   }
6358 }
6359
6360
6361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6362   void * jresult ;
6363   Dali::Vector3 *arg1 = 0 ;
6364   Dali::Vector3 *arg2 = 0 ;
6365   Dali::Vector3 result;
6366
6367   arg1 = (Dali::Vector3 *)jarg1;
6368   if (!arg1) {
6369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6370     return 0;
6371   }
6372   arg2 = (Dali::Vector3 *)jarg2;
6373   if (!arg2) {
6374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6375     return 0;
6376   }
6377   {
6378     try {
6379       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6380     } catch (std::out_of_range& e) {
6381       {
6382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (std::exception& e) {
6385       {
6386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6387       };
6388     } catch (...) {
6389       {
6390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6391       };
6392     }
6393   }
6394   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6395   return jresult;
6396 }
6397
6398
6399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6400   void * jresult ;
6401   Dali::Vector3 *arg1 = 0 ;
6402   Dali::Vector3 *arg2 = 0 ;
6403   Dali::Vector3 result;
6404
6405   arg1 = (Dali::Vector3 *)jarg1;
6406   if (!arg1) {
6407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6408     return 0;
6409   }
6410   arg2 = (Dali::Vector3 *)jarg2;
6411   if (!arg2) {
6412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6413     return 0;
6414   }
6415   {
6416     try {
6417       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6418     } catch (std::out_of_range& e) {
6419       {
6420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6421       };
6422     } catch (std::exception& e) {
6423       {
6424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6425       };
6426     } catch (...) {
6427       {
6428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6429       };
6430     }
6431   }
6432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6438   void * jresult ;
6439   Dali::Vector3 *arg1 = 0 ;
6440   float *arg2 = 0 ;
6441   float *arg3 = 0 ;
6442   float temp2 ;
6443   float temp3 ;
6444   Dali::Vector3 result;
6445
6446   arg1 = (Dali::Vector3 *)jarg1;
6447   if (!arg1) {
6448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6449     return 0;
6450   }
6451   temp2 = (float)jarg2;
6452   arg2 = &temp2;
6453   temp3 = (float)jarg3;
6454   arg3 = &temp3;
6455   {
6456     try {
6457       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (...) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6469       };
6470     }
6471   }
6472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6478   void * jresult ;
6479   Dali::Vector4 *result = 0 ;
6480
6481   {
6482     try {
6483       result = (Dali::Vector4 *)new Dali::Vector4();
6484     } catch (std::out_of_range& e) {
6485       {
6486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (std::exception& e) {
6489       {
6490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6491       };
6492     } catch (...) {
6493       {
6494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6495       };
6496     }
6497   }
6498   jresult = (void *)result;
6499   return jresult;
6500 }
6501
6502
6503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6504   void * jresult ;
6505   float arg1 ;
6506   float arg2 ;
6507   float arg3 ;
6508   float arg4 ;
6509   Dali::Vector4 *result = 0 ;
6510
6511   arg1 = (float)jarg1;
6512   arg2 = (float)jarg2;
6513   arg3 = (float)jarg3;
6514   arg4 = (float)jarg4;
6515   {
6516     try {
6517       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6518     } catch (std::out_of_range& e) {
6519       {
6520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6521       };
6522     } catch (std::exception& e) {
6523       {
6524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6525       };
6526     } catch (...) {
6527       {
6528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6529       };
6530     }
6531   }
6532   jresult = (void *)result;
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6538   void * jresult ;
6539   float *arg1 = (float *) 0 ;
6540   Dali::Vector4 *result = 0 ;
6541
6542   arg1 = jarg1;
6543   {
6544     try {
6545       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6546     } catch (std::out_of_range& e) {
6547       {
6548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6549       };
6550     } catch (std::exception& e) {
6551       {
6552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6553       };
6554     } catch (...) {
6555       {
6556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6557       };
6558     }
6559   }
6560   jresult = (void *)result;
6561
6562
6563   return jresult;
6564 }
6565
6566
6567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6568   void * jresult ;
6569   Dali::Vector2 *arg1 = 0 ;
6570   Dali::Vector4 *result = 0 ;
6571
6572   arg1 = (Dali::Vector2 *)jarg1;
6573   if (!arg1) {
6574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6575     return 0;
6576   }
6577   {
6578     try {
6579       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6580     } catch (std::out_of_range& e) {
6581       {
6582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (std::exception& e) {
6585       {
6586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (...) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6591       };
6592     }
6593   }
6594   jresult = (void *)result;
6595   return jresult;
6596 }
6597
6598
6599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6600   void * jresult ;
6601   Dali::Vector3 *arg1 = 0 ;
6602   Dali::Vector4 *result = 0 ;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   if (!arg1) {
6606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6607     return 0;
6608   }
6609   {
6610     try {
6611       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6612     } catch (std::out_of_range& e) {
6613       {
6614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (std::exception& e) {
6617       {
6618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6619       };
6620     } catch (...) {
6621       {
6622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6623       };
6624     }
6625   }
6626   jresult = (void *)result;
6627   return jresult;
6628 }
6629
6630
6631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6632   void * jresult ;
6633   Dali::Vector4 *result = 0 ;
6634
6635   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6636   jresult = (void *)result;
6637   return jresult;
6638 }
6639
6640
6641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6642   void * jresult ;
6643   Dali::Vector4 *result = 0 ;
6644
6645   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6646   jresult = (void *)result;
6647   return jresult;
6648 }
6649
6650
6651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6652   void * jresult ;
6653   Dali::Vector4 *result = 0 ;
6654
6655   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6656   jresult = (void *)result;
6657   return jresult;
6658 }
6659
6660
6661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6662   void * jresult ;
6663   Dali::Vector4 *result = 0 ;
6664
6665   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6666   jresult = (void *)result;
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6672   void * jresult ;
6673   Dali::Vector4 *result = 0 ;
6674
6675   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6676   jresult = (void *)result;
6677   return jresult;
6678 }
6679
6680
6681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6682   void * jresult ;
6683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6684   float *arg2 = (float *) 0 ;
6685   Dali::Vector4 *result = 0 ;
6686
6687   arg1 = (Dali::Vector4 *)jarg1;
6688   arg2 = jarg2;
6689   {
6690     try {
6691       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6692     } catch (std::out_of_range& e) {
6693       {
6694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (std::exception& e) {
6697       {
6698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6699       };
6700     } catch (...) {
6701       {
6702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6703       };
6704     }
6705   }
6706   jresult = (void *)result;
6707
6708
6709   return jresult;
6710 }
6711
6712
6713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6714   void * jresult ;
6715   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6716   Dali::Vector2 *arg2 = 0 ;
6717   Dali::Vector4 *result = 0 ;
6718
6719   arg1 = (Dali::Vector4 *)jarg1;
6720   arg2 = (Dali::Vector2 *)jarg2;
6721   if (!arg2) {
6722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6723     return 0;
6724   }
6725   {
6726     try {
6727       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6728     } catch (std::out_of_range& e) {
6729       {
6730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6731       };
6732     } catch (std::exception& e) {
6733       {
6734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6735       };
6736     } catch (...) {
6737       {
6738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6739       };
6740     }
6741   }
6742   jresult = (void *)result;
6743   return jresult;
6744 }
6745
6746
6747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6748   void * jresult ;
6749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6750   Dali::Vector3 *arg2 = 0 ;
6751   Dali::Vector4 *result = 0 ;
6752
6753   arg1 = (Dali::Vector4 *)jarg1;
6754   arg2 = (Dali::Vector3 *)jarg2;
6755   if (!arg2) {
6756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6757     return 0;
6758   }
6759   {
6760     try {
6761       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6762     } catch (std::out_of_range& e) {
6763       {
6764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6765       };
6766     } catch (std::exception& e) {
6767       {
6768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6769       };
6770     } catch (...) {
6771       {
6772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6773       };
6774     }
6775   }
6776   jresult = (void *)result;
6777   return jresult;
6778 }
6779
6780
6781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6782   void * jresult ;
6783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6784   Dali::Vector4 *arg2 = 0 ;
6785   Dali::Vector4 result;
6786
6787   arg1 = (Dali::Vector4 *)jarg1;
6788   arg2 = (Dali::Vector4 *)jarg2;
6789   if (!arg2) {
6790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6791     return 0;
6792   }
6793   {
6794     try {
6795       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6796     } catch (std::out_of_range& e) {
6797       {
6798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6799       };
6800     } catch (std::exception& e) {
6801       {
6802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6803       };
6804     } catch (...) {
6805       {
6806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6807       };
6808     }
6809   }
6810   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6811   return jresult;
6812 }
6813
6814
6815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6816   void * jresult ;
6817   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6818   Dali::Vector4 *arg2 = 0 ;
6819   Dali::Vector4 *result = 0 ;
6820
6821   arg1 = (Dali::Vector4 *)jarg1;
6822   arg2 = (Dali::Vector4 *)jarg2;
6823   if (!arg2) {
6824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6825     return 0;
6826   }
6827   {
6828     try {
6829       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6830     } catch (std::out_of_range& e) {
6831       {
6832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (std::exception& e) {
6835       {
6836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6837       };
6838     } catch (...) {
6839       {
6840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6841       };
6842     }
6843   }
6844   jresult = (void *)result;
6845   return jresult;
6846 }
6847
6848
6849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6850   void * jresult ;
6851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6852   Dali::Vector4 *arg2 = 0 ;
6853   Dali::Vector4 result;
6854
6855   arg1 = (Dali::Vector4 *)jarg1;
6856   arg2 = (Dali::Vector4 *)jarg2;
6857   if (!arg2) {
6858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6859     return 0;
6860   }
6861   {
6862     try {
6863       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6864     } catch (std::out_of_range& e) {
6865       {
6866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6867       };
6868     } catch (std::exception& e) {
6869       {
6870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6871       };
6872     } catch (...) {
6873       {
6874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6875       };
6876     }
6877   }
6878   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6879   return jresult;
6880 }
6881
6882
6883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6884   void * jresult ;
6885   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6886   Dali::Vector4 *arg2 = 0 ;
6887   Dali::Vector4 *result = 0 ;
6888
6889   arg1 = (Dali::Vector4 *)jarg1;
6890   arg2 = (Dali::Vector4 *)jarg2;
6891   if (!arg2) {
6892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6893     return 0;
6894   }
6895   {
6896     try {
6897       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6898     } catch (std::out_of_range& e) {
6899       {
6900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6901       };
6902     } catch (std::exception& e) {
6903       {
6904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6905       };
6906     } catch (...) {
6907       {
6908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6909       };
6910     }
6911   }
6912   jresult = (void *)result;
6913   return jresult;
6914 }
6915
6916
6917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6918   void * jresult ;
6919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6920   Dali::Vector4 *arg2 = 0 ;
6921   Dali::Vector4 result;
6922
6923   arg1 = (Dali::Vector4 *)jarg1;
6924   arg2 = (Dali::Vector4 *)jarg2;
6925   if (!arg2) {
6926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6927     return 0;
6928   }
6929   {
6930     try {
6931       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6932     } catch (std::out_of_range& e) {
6933       {
6934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6935       };
6936     } catch (std::exception& e) {
6937       {
6938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6939       };
6940     } catch (...) {
6941       {
6942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6943       };
6944     }
6945   }
6946   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6947   return jresult;
6948 }
6949
6950
6951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6952   void * jresult ;
6953   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6954   float arg2 ;
6955   Dali::Vector4 result;
6956
6957   arg1 = (Dali::Vector4 *)jarg1;
6958   arg2 = (float)jarg2;
6959   {
6960     try {
6961       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6962     } catch (std::out_of_range& e) {
6963       {
6964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6965       };
6966     } catch (std::exception& e) {
6967       {
6968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6969       };
6970     } catch (...) {
6971       {
6972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6973       };
6974     }
6975   }
6976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6977   return jresult;
6978 }
6979
6980
6981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6982   void * jresult ;
6983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6984   Dali::Vector4 *arg2 = 0 ;
6985   Dali::Vector4 *result = 0 ;
6986
6987   arg1 = (Dali::Vector4 *)jarg1;
6988   arg2 = (Dali::Vector4 *)jarg2;
6989   if (!arg2) {
6990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6991     return 0;
6992   }
6993   {
6994     try {
6995       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6996     } catch (std::out_of_range& e) {
6997       {
6998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6999       };
7000     } catch (std::exception& e) {
7001       {
7002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7003       };
7004     } catch (...) {
7005       {
7006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7007       };
7008     }
7009   }
7010   jresult = (void *)result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7016   void * jresult ;
7017   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7018   float arg2 ;
7019   Dali::Vector4 *result = 0 ;
7020
7021   arg1 = (Dali::Vector4 *)jarg1;
7022   arg2 = (float)jarg2;
7023   {
7024     try {
7025       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7026     } catch (std::out_of_range& e) {
7027       {
7028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7029       };
7030     } catch (std::exception& e) {
7031       {
7032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7033       };
7034     } catch (...) {
7035       {
7036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7037       };
7038     }
7039   }
7040   jresult = (void *)result;
7041   return jresult;
7042 }
7043
7044
7045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7046   void * jresult ;
7047   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7048   Dali::Vector4 *arg2 = 0 ;
7049   Dali::Vector4 result;
7050
7051   arg1 = (Dali::Vector4 *)jarg1;
7052   arg2 = (Dali::Vector4 *)jarg2;
7053   if (!arg2) {
7054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7055     return 0;
7056   }
7057   {
7058     try {
7059       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7060     } catch (std::out_of_range& e) {
7061       {
7062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7063       };
7064     } catch (std::exception& e) {
7065       {
7066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7067       };
7068     } catch (...) {
7069       {
7070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7071       };
7072     }
7073   }
7074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7080   void * jresult ;
7081   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7082   float arg2 ;
7083   Dali::Vector4 result;
7084
7085   arg1 = (Dali::Vector4 *)jarg1;
7086   arg2 = (float)jarg2;
7087   {
7088     try {
7089       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7090     } catch (std::out_of_range& e) {
7091       {
7092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7093       };
7094     } catch (std::exception& e) {
7095       {
7096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7097       };
7098     } catch (...) {
7099       {
7100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7101       };
7102     }
7103   }
7104   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7110   void * jresult ;
7111   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7112   Dali::Vector4 *arg2 = 0 ;
7113   Dali::Vector4 *result = 0 ;
7114
7115   arg1 = (Dali::Vector4 *)jarg1;
7116   arg2 = (Dali::Vector4 *)jarg2;
7117   if (!arg2) {
7118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7119     return 0;
7120   }
7121   {
7122     try {
7123       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7124     } catch (std::out_of_range& e) {
7125       {
7126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7127       };
7128     } catch (std::exception& e) {
7129       {
7130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7131       };
7132     } catch (...) {
7133       {
7134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7135       };
7136     }
7137   }
7138   jresult = (void *)result;
7139   return jresult;
7140 }
7141
7142
7143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7144   void * jresult ;
7145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7146   float arg2 ;
7147   Dali::Vector4 *result = 0 ;
7148
7149   arg1 = (Dali::Vector4 *)jarg1;
7150   arg2 = (float)jarg2;
7151   {
7152     try {
7153       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (...) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7165       };
7166     }
7167   }
7168   jresult = (void *)result;
7169   return jresult;
7170 }
7171
7172
7173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7174   void * jresult ;
7175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7176   Dali::Vector4 result;
7177
7178   arg1 = (Dali::Vector4 *)jarg1;
7179   {
7180     try {
7181       result = ((Dali::Vector4 const *)arg1)->operator -();
7182     } catch (std::out_of_range& e) {
7183       {
7184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7185       };
7186     } catch (std::exception& e) {
7187       {
7188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7189       };
7190     } catch (...) {
7191       {
7192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7193       };
7194     }
7195   }
7196   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7197   return jresult;
7198 }
7199
7200
7201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7202   unsigned int jresult ;
7203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7204   Dali::Vector4 *arg2 = 0 ;
7205   bool result;
7206
7207   arg1 = (Dali::Vector4 *)jarg1;
7208   arg2 = (Dali::Vector4 *)jarg2;
7209   if (!arg2) {
7210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7211     return 0;
7212   }
7213   {
7214     try {
7215       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7216     } catch (std::out_of_range& e) {
7217       {
7218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7219       };
7220     } catch (std::exception& e) {
7221       {
7222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7223       };
7224     } catch (...) {
7225       {
7226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7227       };
7228     }
7229   }
7230   jresult = result;
7231   return jresult;
7232 }
7233
7234
7235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7236   unsigned int jresult ;
7237   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7238   Dali::Vector4 *arg2 = 0 ;
7239   bool result;
7240
7241   arg1 = (Dali::Vector4 *)jarg1;
7242   arg2 = (Dali::Vector4 *)jarg2;
7243   if (!arg2) {
7244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7245     return 0;
7246   }
7247   {
7248     try {
7249       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7250     } catch (std::out_of_range& e) {
7251       {
7252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7253       };
7254     } catch (std::exception& e) {
7255       {
7256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (...) {
7259       {
7260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7261       };
7262     }
7263   }
7264   jresult = result;
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7270   float jresult ;
7271   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7272   unsigned int arg2 ;
7273   float *result = 0 ;
7274
7275   arg1 = (Dali::Vector4 *)jarg1;
7276   arg2 = (unsigned int)jarg2;
7277   {
7278     try {
7279       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7280     } catch (std::out_of_range& e) {
7281       {
7282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (std::exception& e) {
7285       {
7286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294   jresult = *result;
7295   return jresult;
7296 }
7297
7298
7299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7300   float jresult ;
7301   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7302   Dali::Vector3 *arg2 = 0 ;
7303   float result;
7304
7305   arg1 = (Dali::Vector4 *)jarg1;
7306   arg2 = (Dali::Vector3 *)jarg2;
7307   if (!arg2) {
7308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7309     return 0;
7310   }
7311   {
7312     try {
7313       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7314     } catch (std::out_of_range& e) {
7315       {
7316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (std::exception& e) {
7319       {
7320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7321       };
7322     } catch (...) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7325       };
7326     }
7327   }
7328   jresult = result;
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7334   float jresult ;
7335   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7336   Dali::Vector4 *arg2 = 0 ;
7337   float result;
7338
7339   arg1 = (Dali::Vector4 *)jarg1;
7340   arg2 = (Dali::Vector4 *)jarg2;
7341   if (!arg2) {
7342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7343     return 0;
7344   }
7345   {
7346     try {
7347       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (...) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7359       };
7360     }
7361   }
7362   jresult = result;
7363   return jresult;
7364 }
7365
7366
7367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7368   float jresult ;
7369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7370   Dali::Vector4 *arg2 = 0 ;
7371   float result;
7372
7373   arg1 = (Dali::Vector4 *)jarg1;
7374   arg2 = (Dali::Vector4 *)jarg2;
7375   if (!arg2) {
7376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7377     return 0;
7378   }
7379   {
7380     try {
7381       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7382     } catch (std::out_of_range& e) {
7383       {
7384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7385       };
7386     } catch (std::exception& e) {
7387       {
7388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7389       };
7390     } catch (...) {
7391       {
7392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7393       };
7394     }
7395   }
7396   jresult = result;
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7402   void * jresult ;
7403   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7404   Dali::Vector4 *arg2 = 0 ;
7405   Dali::Vector4 result;
7406
7407   arg1 = (Dali::Vector4 *)jarg1;
7408   arg2 = (Dali::Vector4 *)jarg2;
7409   if (!arg2) {
7410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7411     return 0;
7412   }
7413   {
7414     try {
7415       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7416     } catch (std::out_of_range& e) {
7417       {
7418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7419       };
7420     } catch (std::exception& e) {
7421       {
7422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7423       };
7424     } catch (...) {
7425       {
7426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7427       };
7428     }
7429   }
7430   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7436   float jresult ;
7437   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7438   float result;
7439
7440   arg1 = (Dali::Vector4 *)jarg1;
7441   {
7442     try {
7443       result = (float)((Dali::Vector4 const *)arg1)->Length();
7444     } catch (std::out_of_range& e) {
7445       {
7446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7447       };
7448     } catch (std::exception& e) {
7449       {
7450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (...) {
7453       {
7454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7455       };
7456     }
7457   }
7458   jresult = result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7464   float jresult ;
7465   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7466   float result;
7467
7468   arg1 = (Dali::Vector4 *)jarg1;
7469   {
7470     try {
7471       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7472     } catch (std::out_of_range& e) {
7473       {
7474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7475       };
7476     } catch (std::exception& e) {
7477       {
7478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7479       };
7480     } catch (...) {
7481       {
7482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7483       };
7484     }
7485   }
7486   jresult = result;
7487   return jresult;
7488 }
7489
7490
7491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7493
7494   arg1 = (Dali::Vector4 *)jarg1;
7495   {
7496     try {
7497       (arg1)->Normalize();
7498     } catch (std::out_of_range& e) {
7499       {
7500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7501       };
7502     } catch (std::exception& e) {
7503       {
7504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7505       };
7506     } catch (...) {
7507       {
7508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7509       };
7510     }
7511   }
7512 }
7513
7514
7515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7516   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7517   Dali::Vector4 *arg2 = 0 ;
7518   Dali::Vector4 *arg3 = 0 ;
7519
7520   arg1 = (Dali::Vector4 *)jarg1;
7521   arg2 = (Dali::Vector4 *)jarg2;
7522   if (!arg2) {
7523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7524     return ;
7525   }
7526   arg3 = (Dali::Vector4 *)jarg3;
7527   if (!arg3) {
7528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7529     return ;
7530   }
7531   {
7532     try {
7533       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7534     } catch (std::out_of_range& e) {
7535       {
7536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7537       };
7538     } catch (std::exception& e) {
7539       {
7540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7541       };
7542     } catch (...) {
7543       {
7544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7545       };
7546     }
7547   }
7548 }
7549
7550
7551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7552   void * jresult ;
7553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7554   float *result = 0 ;
7555
7556   arg1 = (Dali::Vector4 *)jarg1;
7557   {
7558     try {
7559       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7560     } catch (std::out_of_range& e) {
7561       {
7562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7563       };
7564     } catch (std::exception& e) {
7565       {
7566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7567       };
7568     } catch (...) {
7569       {
7570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7571       };
7572     }
7573   }
7574   jresult = (void *)result;
7575   return jresult;
7576 }
7577
7578
7579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7580   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7581   float arg2 ;
7582
7583   arg1 = (Dali::Vector4 *)jarg1;
7584   arg2 = (float)jarg2;
7585   if (arg1) (arg1)->x = arg2;
7586 }
7587
7588
7589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7590   float jresult ;
7591   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7592   float result;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   result = (float) ((arg1)->x);
7596   jresult = result;
7597   return jresult;
7598 }
7599
7600
7601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7603   float arg2 ;
7604
7605   arg1 = (Dali::Vector4 *)jarg1;
7606   arg2 = (float)jarg2;
7607   if (arg1) (arg1)->r = arg2;
7608 }
7609
7610
7611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7612   float jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   float result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   result = (float) ((arg1)->r);
7618   jresult = result;
7619   return jresult;
7620 }
7621
7622
7623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7624   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7625   float arg2 ;
7626
7627   arg1 = (Dali::Vector4 *)jarg1;
7628   arg2 = (float)jarg2;
7629   if (arg1) (arg1)->s = arg2;
7630 }
7631
7632
7633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7634   float jresult ;
7635   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7636   float result;
7637
7638   arg1 = (Dali::Vector4 *)jarg1;
7639   result = (float) ((arg1)->s);
7640   jresult = result;
7641   return jresult;
7642 }
7643
7644
7645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   float arg2 ;
7648
7649   arg1 = (Dali::Vector4 *)jarg1;
7650   arg2 = (float)jarg2;
7651   if (arg1) (arg1)->y = arg2;
7652 }
7653
7654
7655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7656   float jresult ;
7657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7658   float result;
7659
7660   arg1 = (Dali::Vector4 *)jarg1;
7661   result = (float) ((arg1)->y);
7662   jresult = result;
7663   return jresult;
7664 }
7665
7666
7667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7669   float arg2 ;
7670
7671   arg1 = (Dali::Vector4 *)jarg1;
7672   arg2 = (float)jarg2;
7673   if (arg1) (arg1)->g = arg2;
7674 }
7675
7676
7677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7678   float jresult ;
7679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7680   float result;
7681
7682   arg1 = (Dali::Vector4 *)jarg1;
7683   result = (float) ((arg1)->g);
7684   jresult = result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   float arg2 ;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   arg2 = (float)jarg2;
7695   if (arg1) (arg1)->t = arg2;
7696 }
7697
7698
7699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7700   float jresult ;
7701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7702   float result;
7703
7704   arg1 = (Dali::Vector4 *)jarg1;
7705   result = (float) ((arg1)->t);
7706   jresult = result;
7707   return jresult;
7708 }
7709
7710
7711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7713   float arg2 ;
7714
7715   arg1 = (Dali::Vector4 *)jarg1;
7716   arg2 = (float)jarg2;
7717   if (arg1) (arg1)->z = arg2;
7718 }
7719
7720
7721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7722   float jresult ;
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   float result;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   result = (float) ((arg1)->z);
7728   jresult = result;
7729   return jresult;
7730 }
7731
7732
7733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7735   float arg2 ;
7736
7737   arg1 = (Dali::Vector4 *)jarg1;
7738   arg2 = (float)jarg2;
7739   if (arg1) (arg1)->b = arg2;
7740 }
7741
7742
7743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7744   float jresult ;
7745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7746   float result;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   result = (float) ((arg1)->b);
7750   jresult = result;
7751   return jresult;
7752 }
7753
7754
7755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7757   float arg2 ;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   arg2 = (float)jarg2;
7761   if (arg1) (arg1)->p = arg2;
7762 }
7763
7764
7765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7766   float jresult ;
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   float result;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   result = (float) ((arg1)->p);
7772   jresult = result;
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7779   float arg2 ;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   arg2 = (float)jarg2;
7783   if (arg1) (arg1)->w = arg2;
7784 }
7785
7786
7787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7788   float jresult ;
7789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7790   float result;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   result = (float) ((arg1)->w);
7794   jresult = result;
7795   return jresult;
7796 }
7797
7798
7799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7801   float arg2 ;
7802
7803   arg1 = (Dali::Vector4 *)jarg1;
7804   arg2 = (float)jarg2;
7805   if (arg1) (arg1)->a = arg2;
7806 }
7807
7808
7809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7810   float jresult ;
7811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7812   float result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   result = (float) ((arg1)->a);
7816   jresult = result;
7817   return jresult;
7818 }
7819
7820
7821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7822   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7823   float arg2 ;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   arg2 = (float)jarg2;
7827   if (arg1) (arg1)->q = arg2;
7828 }
7829
7830
7831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7832   float jresult ;
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float result;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   result = (float) ((arg1)->q);
7838   jresult = result;
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   {
7848     try {
7849       delete arg1;
7850     } catch (std::out_of_range& e) {
7851       {
7852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7853       };
7854     } catch (std::exception& e) {
7855       {
7856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7857       };
7858     } catch (...) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7861       };
7862     }
7863   }
7864 }
7865
7866
7867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7868   void * jresult ;
7869   Dali::Vector4 *arg1 = 0 ;
7870   Dali::Vector4 *arg2 = 0 ;
7871   Dali::Vector4 result;
7872
7873   arg1 = (Dali::Vector4 *)jarg1;
7874   if (!arg1) {
7875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7876     return 0;
7877   }
7878   arg2 = (Dali::Vector4 *)jarg2;
7879   if (!arg2) {
7880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7881     return 0;
7882   }
7883   {
7884     try {
7885       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7886     } catch (std::out_of_range& e) {
7887       {
7888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7889       };
7890     } catch (std::exception& e) {
7891       {
7892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (...) {
7895       {
7896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7897       };
7898     }
7899   }
7900   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7901   return jresult;
7902 }
7903
7904
7905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7906   void * jresult ;
7907   Dali::Vector4 *arg1 = 0 ;
7908   Dali::Vector4 *arg2 = 0 ;
7909   Dali::Vector4 result;
7910
7911   arg1 = (Dali::Vector4 *)jarg1;
7912   if (!arg1) {
7913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7914     return 0;
7915   }
7916   arg2 = (Dali::Vector4 *)jarg2;
7917   if (!arg2) {
7918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7919     return 0;
7920   }
7921   {
7922     try {
7923       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7924     } catch (std::out_of_range& e) {
7925       {
7926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (std::exception& e) {
7929       {
7930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7931       };
7932     } catch (...) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7935       };
7936     }
7937   }
7938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = 0 ;
7946   float *arg2 = 0 ;
7947   float *arg3 = 0 ;
7948   float temp2 ;
7949   float temp3 ;
7950   Dali::Vector4 result;
7951
7952   arg1 = (Dali::Vector4 *)jarg1;
7953   if (!arg1) {
7954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7955     return 0;
7956   }
7957   temp2 = (float)jarg2;
7958   arg2 = &temp2;
7959   temp3 = (float)jarg3;
7960   arg3 = &temp3;
7961   {
7962     try {
7963       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (...) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7975       };
7976     }
7977   }
7978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7984   void * jresult ;
7985   Dali::Uint16Pair *result = 0 ;
7986
7987   {
7988     try {
7989       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7990     } catch (std::out_of_range& e) {
7991       {
7992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (std::exception& e) {
7995       {
7996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (...) {
7999       {
8000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8001       };
8002     }
8003   }
8004   jresult = (void *)result;
8005   return jresult;
8006 }
8007
8008
8009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8010   void * jresult ;
8011   uint32_t arg1 ;
8012   uint32_t arg2 ;
8013   Dali::Uint16Pair *result = 0 ;
8014
8015   arg1 = (uint32_t)jarg1;
8016   arg2 = (uint32_t)jarg2;
8017   {
8018     try {
8019       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8020     } catch (std::out_of_range& e) {
8021       {
8022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8023       };
8024     } catch (std::exception& e) {
8025       {
8026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (...) {
8029       {
8030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8031       };
8032     }
8033   }
8034   jresult = (void *)result;
8035   return jresult;
8036 }
8037
8038
8039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8040   void * jresult ;
8041   Dali::Uint16Pair *arg1 = 0 ;
8042   Dali::Uint16Pair *result = 0 ;
8043
8044   arg1 = (Dali::Uint16Pair *)jarg1;
8045   if (!arg1) {
8046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8047     return 0;
8048   }
8049   {
8050     try {
8051       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8052     } catch (std::out_of_range& e) {
8053       {
8054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8055       };
8056     } catch (std::exception& e) {
8057       {
8058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8059       };
8060     } catch (...) {
8061       {
8062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8063       };
8064     }
8065   }
8066   jresult = (void *)result;
8067   return jresult;
8068 }
8069
8070
8071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8072   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8073   uint16_t arg2 ;
8074
8075   arg1 = (Dali::Uint16Pair *)jarg1;
8076   arg2 = (uint16_t)jarg2;
8077   {
8078     try {
8079       (arg1)->SetWidth(arg2);
8080     } catch (std::out_of_range& e) {
8081       {
8082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8083       };
8084     } catch (std::exception& e) {
8085       {
8086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8087       };
8088     } catch (...) {
8089       {
8090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8091       };
8092     }
8093   }
8094 }
8095
8096
8097 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8098   unsigned short jresult ;
8099   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8100   uint16_t result;
8101
8102   arg1 = (Dali::Uint16Pair *)jarg1;
8103   {
8104     try {
8105       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8106     } catch (std::out_of_range& e) {
8107       {
8108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8109       };
8110     } catch (std::exception& e) {
8111       {
8112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (...) {
8115       {
8116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8117       };
8118     }
8119   }
8120   jresult = result;
8121   return jresult;
8122 }
8123
8124
8125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8127   uint16_t arg2 ;
8128
8129   arg1 = (Dali::Uint16Pair *)jarg1;
8130   arg2 = (uint16_t)jarg2;
8131   {
8132     try {
8133       (arg1)->SetHeight(arg2);
8134     } catch (std::out_of_range& e) {
8135       {
8136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8137       };
8138     } catch (std::exception& e) {
8139       {
8140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8141       };
8142     } catch (...) {
8143       {
8144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8145       };
8146     }
8147   }
8148 }
8149
8150
8151 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8152   unsigned short jresult ;
8153   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8154   uint16_t result;
8155
8156   arg1 = (Dali::Uint16Pair *)jarg1;
8157   {
8158     try {
8159       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8160     } catch (std::out_of_range& e) {
8161       {
8162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8163       };
8164     } catch (std::exception& e) {
8165       {
8166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8167       };
8168     } catch (...) {
8169       {
8170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8171       };
8172     }
8173   }
8174   jresult = result;
8175   return jresult;
8176 }
8177
8178
8179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8180   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8181   uint16_t arg2 ;
8182
8183   arg1 = (Dali::Uint16Pair *)jarg1;
8184   arg2 = (uint16_t)jarg2;
8185   {
8186     try {
8187       (arg1)->SetX(arg2);
8188     } catch (std::out_of_range& e) {
8189       {
8190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8191       };
8192     } catch (std::exception& e) {
8193       {
8194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8199       };
8200     }
8201   }
8202 }
8203
8204
8205 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8206   unsigned short jresult ;
8207   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8208   uint16_t result;
8209
8210   arg1 = (Dali::Uint16Pair *)jarg1;
8211   {
8212     try {
8213       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8214     } catch (std::out_of_range& e) {
8215       {
8216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8217       };
8218     } catch (std::exception& e) {
8219       {
8220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8225       };
8226     }
8227   }
8228   jresult = result;
8229   return jresult;
8230 }
8231
8232
8233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8234   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8235   uint16_t arg2 ;
8236
8237   arg1 = (Dali::Uint16Pair *)jarg1;
8238   arg2 = (uint16_t)jarg2;
8239   {
8240     try {
8241       (arg1)->SetY(arg2);
8242     } catch (std::out_of_range& e) {
8243       {
8244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8245       };
8246     } catch (std::exception& e) {
8247       {
8248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8249       };
8250     } catch (...) {
8251       {
8252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8253       };
8254     }
8255   }
8256 }
8257
8258
8259 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8260   unsigned short jresult ;
8261   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8262   uint16_t result;
8263
8264   arg1 = (Dali::Uint16Pair *)jarg1;
8265   {
8266     try {
8267       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8268     } catch (std::out_of_range& e) {
8269       {
8270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8271       };
8272     } catch (std::exception& e) {
8273       {
8274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8275       };
8276     } catch (...) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8279       };
8280     }
8281   }
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8288   void * jresult ;
8289   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8290   Dali::Uint16Pair *arg2 = 0 ;
8291   Dali::Uint16Pair *result = 0 ;
8292
8293   arg1 = (Dali::Uint16Pair *)jarg1;
8294   arg2 = (Dali::Uint16Pair *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (...) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8313       };
8314     }
8315   }
8316   jresult = (void *)result;
8317   return jresult;
8318 }
8319
8320
8321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8322   unsigned int jresult ;
8323   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8324   Dali::Uint16Pair *arg2 = 0 ;
8325   bool result;
8326
8327   arg1 = (Dali::Uint16Pair *)jarg1;
8328   arg2 = (Dali::Uint16Pair *)jarg2;
8329   if (!arg2) {
8330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8331     return 0;
8332   }
8333   {
8334     try {
8335       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8336     } catch (std::out_of_range& e) {
8337       {
8338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8339       };
8340     } catch (std::exception& e) {
8341       {
8342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (...) {
8345       {
8346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8347       };
8348     }
8349   }
8350   jresult = result;
8351   return jresult;
8352 }
8353
8354
8355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8356   unsigned int jresult ;
8357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8358   Dali::Uint16Pair *arg2 = 0 ;
8359   bool result;
8360
8361   arg1 = (Dali::Uint16Pair *)jarg1;
8362   arg2 = (Dali::Uint16Pair *)jarg2;
8363   if (!arg2) {
8364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8365     return 0;
8366   }
8367   {
8368     try {
8369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8370     } catch (std::out_of_range& e) {
8371       {
8372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (std::exception& e) {
8375       {
8376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (...) {
8379       {
8380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8381       };
8382     }
8383   }
8384   jresult = result;
8385   return jresult;
8386 }
8387
8388
8389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8390   unsigned int jresult ;
8391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8392   Dali::Uint16Pair *arg2 = 0 ;
8393   bool result;
8394
8395   arg1 = (Dali::Uint16Pair *)jarg1;
8396   arg2 = (Dali::Uint16Pair *)jarg2;
8397   if (!arg2) {
8398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8399     return 0;
8400   }
8401   {
8402     try {
8403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8404     } catch (std::out_of_range& e) {
8405       {
8406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8407       };
8408     } catch (std::exception& e) {
8409       {
8410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8411       };
8412     } catch (...) {
8413       {
8414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8415       };
8416     }
8417   }
8418   jresult = result;
8419   return jresult;
8420 }
8421
8422
8423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8424   unsigned int jresult ;
8425   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8426   Dali::Uint16Pair *arg2 = 0 ;
8427   bool result;
8428
8429   arg1 = (Dali::Uint16Pair *)jarg1;
8430   arg2 = (Dali::Uint16Pair *)jarg2;
8431   if (!arg2) {
8432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8433     return 0;
8434   }
8435   {
8436     try {
8437       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8449       };
8450     }
8451   }
8452   jresult = result;
8453   return jresult;
8454 }
8455
8456
8457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8458   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8459
8460   arg1 = (Dali::Uint16Pair *)jarg1;
8461   {
8462     try {
8463       delete arg1;
8464     } catch (std::out_of_range& e) {
8465       {
8466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8467       };
8468     } catch (std::exception& e) {
8469       {
8470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8471       };
8472     } catch (...) {
8473       {
8474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8475       };
8476     }
8477   }
8478 }
8479
8480
8481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8482   void * jresult ;
8483   Dali::Degree *result = 0 ;
8484
8485   {
8486     try {
8487       result = (Dali::Degree *)new Dali::Degree();
8488     } catch (std::out_of_range& e) {
8489       {
8490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8491       };
8492     } catch (std::exception& e) {
8493       {
8494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8495       };
8496     } catch (...) {
8497       {
8498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8499       };
8500     }
8501   }
8502   jresult = (void *)result;
8503   return jresult;
8504 }
8505
8506
8507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8508   void * jresult ;
8509   float arg1 ;
8510   Dali::Degree *result = 0 ;
8511
8512   arg1 = (float)jarg1;
8513   {
8514     try {
8515       result = (Dali::Degree *)new Dali::Degree(arg1);
8516     } catch (std::out_of_range& e) {
8517       {
8518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (std::exception& e) {
8521       {
8522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530   jresult = (void *)result;
8531   return jresult;
8532 }
8533
8534
8535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8536   void * jresult ;
8537   Dali::Radian arg1 ;
8538   Dali::Radian *argp1 ;
8539   Dali::Degree *result = 0 ;
8540
8541   argp1 = (Dali::Radian *)jarg1;
8542   if (!argp1) {
8543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8544     return 0;
8545   }
8546   arg1 = *argp1;
8547   {
8548     try {
8549       result = (Dali::Degree *)new Dali::Degree(arg1);
8550     } catch (std::out_of_range& e) {
8551       {
8552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8553       };
8554     } catch (std::exception& e) {
8555       {
8556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8557       };
8558     } catch (...) {
8559       {
8560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8561       };
8562     }
8563   }
8564   jresult = (void *)result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8570   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8571   float arg2 ;
8572
8573   arg1 = (Dali::Degree *)jarg1;
8574   arg2 = (float)jarg2;
8575   if (arg1) (arg1)->degree = arg2;
8576 }
8577
8578
8579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8580   float jresult ;
8581   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8582   float result;
8583
8584   arg1 = (Dali::Degree *)jarg1;
8585   result = (float) ((arg1)->degree);
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8592   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8593
8594   arg1 = (Dali::Degree *)jarg1;
8595   {
8596     try {
8597       delete arg1;
8598     } catch (std::out_of_range& e) {
8599       {
8600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8601       };
8602     } catch (std::exception& e) {
8603       {
8604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8605       };
8606     } catch (...) {
8607       {
8608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8609       };
8610     }
8611   }
8612 }
8613
8614
8615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8616   void * jresult ;
8617   Dali::Radian *result = 0 ;
8618
8619   result = (Dali::Radian *)&Dali::ANGLE_360;
8620   jresult = (void *)result;
8621   return jresult;
8622 }
8623
8624
8625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8626   void * jresult ;
8627   Dali::Radian *result = 0 ;
8628
8629   result = (Dali::Radian *)&Dali::ANGLE_315;
8630   jresult = (void *)result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8636   void * jresult ;
8637   Dali::Radian *result = 0 ;
8638
8639   result = (Dali::Radian *)&Dali::ANGLE_270;
8640   jresult = (void *)result;
8641   return jresult;
8642 }
8643
8644
8645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8646   void * jresult ;
8647   Dali::Radian *result = 0 ;
8648
8649   result = (Dali::Radian *)&Dali::ANGLE_225;
8650   jresult = (void *)result;
8651   return jresult;
8652 }
8653
8654
8655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8656   void * jresult ;
8657   Dali::Radian *result = 0 ;
8658
8659   result = (Dali::Radian *)&Dali::ANGLE_180;
8660   jresult = (void *)result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8666   void * jresult ;
8667   Dali::Radian *result = 0 ;
8668
8669   result = (Dali::Radian *)&Dali::ANGLE_135;
8670   jresult = (void *)result;
8671   return jresult;
8672 }
8673
8674
8675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8676   void * jresult ;
8677   Dali::Radian *result = 0 ;
8678
8679   result = (Dali::Radian *)&Dali::ANGLE_120;
8680   jresult = (void *)result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8686   void * jresult ;
8687   Dali::Radian *result = 0 ;
8688
8689   result = (Dali::Radian *)&Dali::ANGLE_90;
8690   jresult = (void *)result;
8691   return jresult;
8692 }
8693
8694
8695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8696   void * jresult ;
8697   Dali::Radian *result = 0 ;
8698
8699   result = (Dali::Radian *)&Dali::ANGLE_60;
8700   jresult = (void *)result;
8701   return jresult;
8702 }
8703
8704
8705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8706   void * jresult ;
8707   Dali::Radian *result = 0 ;
8708
8709   result = (Dali::Radian *)&Dali::ANGLE_45;
8710   jresult = (void *)result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_30;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_0;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8736   unsigned int jresult ;
8737   Dali::Degree *arg1 = 0 ;
8738   Dali::Degree *arg2 = 0 ;
8739   bool result;
8740
8741   arg1 = (Dali::Degree *)jarg1;
8742   if (!arg1) {
8743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8744     return 0;
8745   }
8746   arg2 = (Dali::Degree *)jarg2;
8747   if (!arg2) {
8748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8749     return 0;
8750   }
8751   {
8752     try {
8753       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8754     } catch (std::out_of_range& e) {
8755       {
8756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8757       };
8758     } catch (std::exception& e) {
8759       {
8760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8761       };
8762     } catch (...) {
8763       {
8764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8765       };
8766     }
8767   }
8768   jresult = result;
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8774   unsigned int jresult ;
8775   Dali::Degree *arg1 = 0 ;
8776   Dali::Degree *arg2 = 0 ;
8777   bool result;
8778
8779   arg1 = (Dali::Degree *)jarg1;
8780   if (!arg1) {
8781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8782     return 0;
8783   }
8784   arg2 = (Dali::Degree *)jarg2;
8785   if (!arg2) {
8786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8787     return 0;
8788   }
8789   {
8790     try {
8791       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8792     } catch (std::out_of_range& e) {
8793       {
8794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8795       };
8796     } catch (std::exception& e) {
8797       {
8798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8799       };
8800     } catch (...) {
8801       {
8802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8803       };
8804     }
8805   }
8806   jresult = result;
8807   return jresult;
8808 }
8809
8810
8811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8812   void * jresult ;
8813   Dali::Degree arg1 ;
8814   float arg2 ;
8815   float arg3 ;
8816   Dali::Degree *argp1 ;
8817   Dali::Degree result;
8818
8819   argp1 = (Dali::Degree *)jarg1;
8820   if (!argp1) {
8821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8822     return 0;
8823   }
8824   arg1 = *argp1;
8825   arg2 = (float)jarg2;
8826   arg3 = (float)jarg3;
8827   {
8828     try {
8829       result = Dali::Clamp(arg1,arg2,arg3);
8830     } catch (std::out_of_range& e) {
8831       {
8832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8833       };
8834     } catch (std::exception& e) {
8835       {
8836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8837       };
8838     } catch (...) {
8839       {
8840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8841       };
8842     }
8843   }
8844   jresult = new Dali::Degree((const Dali::Degree &)result);
8845   return jresult;
8846 }
8847
8848
8849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8850   void * jresult ;
8851   Dali::Radian *result = 0 ;
8852
8853   {
8854     try {
8855       result = (Dali::Radian *)new Dali::Radian();
8856     } catch (std::out_of_range& e) {
8857       {
8858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8859       };
8860     } catch (std::exception& e) {
8861       {
8862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8863       };
8864     } catch (...) {
8865       {
8866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8867       };
8868     }
8869   }
8870   jresult = (void *)result;
8871   return jresult;
8872 }
8873
8874
8875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8876   void * jresult ;
8877   float arg1 ;
8878   Dali::Radian *result = 0 ;
8879
8880   arg1 = (float)jarg1;
8881   {
8882     try {
8883       result = (Dali::Radian *)new Dali::Radian(arg1);
8884     } catch (std::out_of_range& e) {
8885       {
8886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8887       };
8888     } catch (std::exception& e) {
8889       {
8890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (...) {
8893       {
8894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8895       };
8896     }
8897   }
8898   jresult = (void *)result;
8899   return jresult;
8900 }
8901
8902
8903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8904   void * jresult ;
8905   Dali::Degree arg1 ;
8906   Dali::Degree *argp1 ;
8907   Dali::Radian *result = 0 ;
8908
8909   argp1 = (Dali::Degree *)jarg1;
8910   if (!argp1) {
8911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8912     return 0;
8913   }
8914   arg1 = *argp1;
8915   {
8916     try {
8917       result = (Dali::Radian *)new Dali::Radian(arg1);
8918     } catch (std::out_of_range& e) {
8919       {
8920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (std::exception& e) {
8923       {
8924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8925       };
8926     } catch (...) {
8927       {
8928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8929       };
8930     }
8931   }
8932   jresult = (void *)result;
8933   return jresult;
8934 }
8935
8936
8937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8938   void * jresult ;
8939   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8940   float arg2 ;
8941   Dali::Radian *result = 0 ;
8942
8943   arg1 = (Dali::Radian *)jarg1;
8944   arg2 = (float)jarg2;
8945   {
8946     try {
8947       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8948     } catch (std::out_of_range& e) {
8949       {
8950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8951       };
8952     } catch (std::exception& e) {
8953       {
8954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8955       };
8956     } catch (...) {
8957       {
8958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8959       };
8960     }
8961   }
8962   jresult = (void *)result;
8963   return jresult;
8964 }
8965
8966
8967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8968   void * jresult ;
8969   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8970   Dali::Degree arg2 ;
8971   Dali::Degree *argp2 ;
8972   Dali::Radian *result = 0 ;
8973
8974   arg1 = (Dali::Radian *)jarg1;
8975   argp2 = (Dali::Degree *)jarg2;
8976   if (!argp2) {
8977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8978     return 0;
8979   }
8980   arg2 = *argp2;
8981   {
8982     try {
8983       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8984     } catch (std::out_of_range& e) {
8985       {
8986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8987       };
8988     } catch (std::exception& e) {
8989       {
8990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8991       };
8992     } catch (...) {
8993       {
8994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8995       };
8996     }
8997   }
8998   jresult = (void *)result;
8999   return jresult;
9000 }
9001
9002
9003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9004   float jresult ;
9005   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9006   float result;
9007
9008   arg1 = (Dali::Radian *)jarg1;
9009   {
9010     try {
9011       result = (float)((Dali::Radian const *)arg1)->operator float();
9012     } catch (std::out_of_range& e) {
9013       {
9014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9015       };
9016     } catch (std::exception& e) {
9017       {
9018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9019       };
9020     } catch (...) {
9021       {
9022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9023       };
9024     }
9025   }
9026   jresult = result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9032   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9033   float arg2 ;
9034
9035   arg1 = (Dali::Radian *)jarg1;
9036   arg2 = (float)jarg2;
9037   if (arg1) (arg1)->radian = arg2;
9038 }
9039
9040
9041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9042   float jresult ;
9043   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9044   float result;
9045
9046   arg1 = (Dali::Radian *)jarg1;
9047   result = (float) ((arg1)->radian);
9048   jresult = result;
9049   return jresult;
9050 }
9051
9052
9053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9054   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9055
9056   arg1 = (Dali::Radian *)jarg1;
9057   {
9058     try {
9059       delete arg1;
9060     } catch (std::out_of_range& e) {
9061       {
9062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9063       };
9064     } catch (std::exception& e) {
9065       {
9066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9071       };
9072     }
9073   }
9074 }
9075
9076
9077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9078   unsigned int jresult ;
9079   Dali::Radian arg1 ;
9080   Dali::Radian arg2 ;
9081   Dali::Radian *argp1 ;
9082   Dali::Radian *argp2 ;
9083   bool result;
9084
9085   argp1 = (Dali::Radian *)jarg1;
9086   if (!argp1) {
9087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9088     return 0;
9089   }
9090   arg1 = *argp1;
9091   argp2 = (Dali::Radian *)jarg2;
9092   if (!argp2) {
9093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9094     return 0;
9095   }
9096   arg2 = *argp2;
9097   {
9098     try {
9099       result = (bool)Dali::operator ==(arg1,arg2);
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (...) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9111       };
9112     }
9113   }
9114   jresult = result;
9115   return jresult;
9116 }
9117
9118
9119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9120   unsigned int jresult ;
9121   Dali::Radian arg1 ;
9122   Dali::Radian arg2 ;
9123   Dali::Radian *argp1 ;
9124   Dali::Radian *argp2 ;
9125   bool result;
9126
9127   argp1 = (Dali::Radian *)jarg1;
9128   if (!argp1) {
9129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9130     return 0;
9131   }
9132   arg1 = *argp1;
9133   argp2 = (Dali::Radian *)jarg2;
9134   if (!argp2) {
9135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9136     return 0;
9137   }
9138   arg2 = *argp2;
9139   {
9140     try {
9141       result = (bool)Dali::operator !=(arg1,arg2);
9142     } catch (std::out_of_range& e) {
9143       {
9144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9145       };
9146     } catch (std::exception& e) {
9147       {
9148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9149       };
9150     } catch (...) {
9151       {
9152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9153       };
9154     }
9155   }
9156   jresult = result;
9157   return jresult;
9158 }
9159
9160
9161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9162   unsigned int jresult ;
9163   Dali::Radian arg1 ;
9164   Dali::Degree arg2 ;
9165   Dali::Radian *argp1 ;
9166   Dali::Degree *argp2 ;
9167   bool result;
9168
9169   argp1 = (Dali::Radian *)jarg1;
9170   if (!argp1) {
9171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9172     return 0;
9173   }
9174   arg1 = *argp1;
9175   argp2 = (Dali::Degree *)jarg2;
9176   if (!argp2) {
9177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9178     return 0;
9179   }
9180   arg2 = *argp2;
9181   {
9182     try {
9183       result = (bool)Dali::operator ==(arg1,arg2);
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9191       };
9192     } catch (...) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9195       };
9196     }
9197   }
9198   jresult = result;
9199   return jresult;
9200 }
9201
9202
9203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9204   unsigned int jresult ;
9205   Dali::Radian arg1 ;
9206   Dali::Degree arg2 ;
9207   Dali::Radian *argp1 ;
9208   Dali::Degree *argp2 ;
9209   bool result;
9210
9211   argp1 = (Dali::Radian *)jarg1;
9212   if (!argp1) {
9213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9214     return 0;
9215   }
9216   arg1 = *argp1;
9217   argp2 = (Dali::Degree *)jarg2;
9218   if (!argp2) {
9219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9220     return 0;
9221   }
9222   arg2 = *argp2;
9223   {
9224     try {
9225       result = (bool)Dali::operator !=(arg1,arg2);
9226     } catch (std::out_of_range& e) {
9227       {
9228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (std::exception& e) {
9231       {
9232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (...) {
9235       {
9236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9237       };
9238     }
9239   }
9240   jresult = result;
9241   return jresult;
9242 }
9243
9244
9245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9246   unsigned int jresult ;
9247   Dali::Degree arg1 ;
9248   Dali::Radian arg2 ;
9249   Dali::Degree *argp1 ;
9250   Dali::Radian *argp2 ;
9251   bool result;
9252
9253   argp1 = (Dali::Degree *)jarg1;
9254   if (!argp1) {
9255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9256     return 0;
9257   }
9258   arg1 = *argp1;
9259   argp2 = (Dali::Radian *)jarg2;
9260   if (!argp2) {
9261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9262     return 0;
9263   }
9264   arg2 = *argp2;
9265   {
9266     try {
9267       result = (bool)Dali::operator ==(arg1,arg2);
9268     } catch (std::out_of_range& e) {
9269       {
9270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9271       };
9272     } catch (std::exception& e) {
9273       {
9274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9279       };
9280     }
9281   }
9282   jresult = result;
9283   return jresult;
9284 }
9285
9286
9287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9288   unsigned int jresult ;
9289   Dali::Degree arg1 ;
9290   Dali::Radian arg2 ;
9291   Dali::Degree *argp1 ;
9292   Dali::Radian *argp2 ;
9293   bool result;
9294
9295   argp1 = (Dali::Degree *)jarg1;
9296   if (!argp1) {
9297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9298     return 0;
9299   }
9300   arg1 = *argp1;
9301   argp2 = (Dali::Radian *)jarg2;
9302   if (!argp2) {
9303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9304     return 0;
9305   }
9306   arg2 = *argp2;
9307   {
9308     try {
9309       result = (bool)Dali::operator !=(arg1,arg2);
9310     } catch (std::out_of_range& e) {
9311       {
9312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9313       };
9314     } catch (std::exception& e) {
9315       {
9316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9317       };
9318     } catch (...) {
9319       {
9320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9321       };
9322     }
9323   }
9324   jresult = result;
9325   return jresult;
9326 }
9327
9328
9329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9330   unsigned int jresult ;
9331   Dali::Radian arg1 ;
9332   Dali::Radian arg2 ;
9333   Dali::Radian *argp1 ;
9334   Dali::Radian *argp2 ;
9335   bool result;
9336
9337   argp1 = (Dali::Radian *)jarg1;
9338   if (!argp1) {
9339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9340     return 0;
9341   }
9342   arg1 = *argp1;
9343   argp2 = (Dali::Radian *)jarg2;
9344   if (!argp2) {
9345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9346     return 0;
9347   }
9348   arg2 = *argp2;
9349   {
9350     try {
9351       result = (bool)Dali::operator >(arg1,arg2);
9352     } catch (std::out_of_range& e) {
9353       {
9354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (std::exception& e) {
9357       {
9358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9359       };
9360     } catch (...) {
9361       {
9362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9363       };
9364     }
9365   }
9366   jresult = result;
9367   return jresult;
9368 }
9369
9370
9371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9372   unsigned int jresult ;
9373   Dali::Radian arg1 ;
9374   Dali::Degree arg2 ;
9375   Dali::Radian *argp1 ;
9376   Dali::Degree *argp2 ;
9377   bool result;
9378
9379   argp1 = (Dali::Radian *)jarg1;
9380   if (!argp1) {
9381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9382     return 0;
9383   }
9384   arg1 = *argp1;
9385   argp2 = (Dali::Degree *)jarg2;
9386   if (!argp2) {
9387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9388     return 0;
9389   }
9390   arg2 = *argp2;
9391   {
9392     try {
9393       result = (bool)Dali::operator >(arg1,arg2);
9394     } catch (std::out_of_range& e) {
9395       {
9396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9397       };
9398     } catch (std::exception& e) {
9399       {
9400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9401       };
9402     } catch (...) {
9403       {
9404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9405       };
9406     }
9407   }
9408   jresult = result;
9409   return jresult;
9410 }
9411
9412
9413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9414   unsigned int jresult ;
9415   Dali::Degree arg1 ;
9416   Dali::Radian arg2 ;
9417   Dali::Degree *argp1 ;
9418   Dali::Radian *argp2 ;
9419   bool result;
9420
9421   argp1 = (Dali::Degree *)jarg1;
9422   if (!argp1) {
9423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9424     return 0;
9425   }
9426   arg1 = *argp1;
9427   argp2 = (Dali::Radian *)jarg2;
9428   if (!argp2) {
9429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9430     return 0;
9431   }
9432   arg2 = *argp2;
9433   {
9434     try {
9435       result = (bool)Dali::operator >(arg1,arg2);
9436     } catch (std::out_of_range& e) {
9437       {
9438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9439       };
9440     } catch (std::exception& e) {
9441       {
9442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9443       };
9444     } catch (...) {
9445       {
9446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9447       };
9448     }
9449   }
9450   jresult = result;
9451   return jresult;
9452 }
9453
9454
9455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9456   unsigned int jresult ;
9457   Dali::Radian arg1 ;
9458   Dali::Radian arg2 ;
9459   Dali::Radian *argp1 ;
9460   Dali::Radian *argp2 ;
9461   bool result;
9462
9463   argp1 = (Dali::Radian *)jarg1;
9464   if (!argp1) {
9465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9466     return 0;
9467   }
9468   arg1 = *argp1;
9469   argp2 = (Dali::Radian *)jarg2;
9470   if (!argp2) {
9471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9472     return 0;
9473   }
9474   arg2 = *argp2;
9475   {
9476     try {
9477       result = (bool)Dali::operator <(arg1,arg2);
9478     } catch (std::out_of_range& e) {
9479       {
9480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (std::exception& e) {
9483       {
9484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9489       };
9490     }
9491   }
9492   jresult = result;
9493   return jresult;
9494 }
9495
9496
9497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9498   unsigned int jresult ;
9499   Dali::Radian arg1 ;
9500   Dali::Degree arg2 ;
9501   Dali::Radian *argp1 ;
9502   Dali::Degree *argp2 ;
9503   bool result;
9504
9505   argp1 = (Dali::Radian *)jarg1;
9506   if (!argp1) {
9507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9508     return 0;
9509   }
9510   arg1 = *argp1;
9511   argp2 = (Dali::Degree *)jarg2;
9512   if (!argp2) {
9513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9514     return 0;
9515   }
9516   arg2 = *argp2;
9517   {
9518     try {
9519       result = (bool)Dali::operator <(arg1,arg2);
9520     } catch (std::out_of_range& e) {
9521       {
9522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9523       };
9524     } catch (std::exception& e) {
9525       {
9526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9527       };
9528     } catch (...) {
9529       {
9530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9531       };
9532     }
9533   }
9534   jresult = result;
9535   return jresult;
9536 }
9537
9538
9539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9540   unsigned int jresult ;
9541   Dali::Degree arg1 ;
9542   Dali::Radian arg2 ;
9543   Dali::Degree *argp1 ;
9544   Dali::Radian *argp2 ;
9545   bool result;
9546
9547   argp1 = (Dali::Degree *)jarg1;
9548   if (!argp1) {
9549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9550     return 0;
9551   }
9552   arg1 = *argp1;
9553   argp2 = (Dali::Radian *)jarg2;
9554   if (!argp2) {
9555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9556     return 0;
9557   }
9558   arg2 = *argp2;
9559   {
9560     try {
9561       result = (bool)Dali::operator <(arg1,arg2);
9562     } catch (std::out_of_range& e) {
9563       {
9564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9565       };
9566     } catch (std::exception& e) {
9567       {
9568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9569       };
9570     } catch (...) {
9571       {
9572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9573       };
9574     }
9575   }
9576   jresult = result;
9577   return jresult;
9578 }
9579
9580
9581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9582   void * jresult ;
9583   Dali::Radian arg1 ;
9584   float arg2 ;
9585   Dali::Radian *argp1 ;
9586   Dali::Radian result;
9587
9588   argp1 = (Dali::Radian *)jarg1;
9589   if (!argp1) {
9590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9591     return 0;
9592   }
9593   arg1 = *argp1;
9594   arg2 = (float)jarg2;
9595   {
9596     try {
9597       result = Dali::operator *(arg1,arg2);
9598     } catch (std::out_of_range& e) {
9599       {
9600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9601       };
9602     } catch (std::exception& e) {
9603       {
9604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9605       };
9606     } catch (...) {
9607       {
9608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9609       };
9610     }
9611   }
9612   jresult = new Dali::Radian((const Dali::Radian &)result);
9613   return jresult;
9614 }
9615
9616
9617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9618   void * jresult ;
9619   Dali::Radian arg1 ;
9620   Dali::Radian *argp1 ;
9621   Dali::Radian result;
9622
9623   argp1 = (Dali::Radian *)jarg1;
9624   if (!argp1) {
9625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9626     return 0;
9627   }
9628   arg1 = *argp1;
9629   {
9630     try {
9631       result = Dali::operator -(arg1);
9632     } catch (std::out_of_range& e) {
9633       {
9634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9635       };
9636     } catch (std::exception& e) {
9637       {
9638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9639       };
9640     } catch (...) {
9641       {
9642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9643       };
9644     }
9645   }
9646   jresult = new Dali::Radian((const Dali::Radian &)result);
9647   return jresult;
9648 }
9649
9650
9651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9652   void * jresult ;
9653   Dali::Radian arg1 ;
9654   float arg2 ;
9655   float arg3 ;
9656   Dali::Radian *argp1 ;
9657   Dali::Radian result;
9658
9659   argp1 = (Dali::Radian *)jarg1;
9660   if (!argp1) {
9661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9662     return 0;
9663   }
9664   arg1 = *argp1;
9665   arg2 = (float)jarg2;
9666   arg3 = (float)jarg3;
9667   {
9668     try {
9669       result = Dali::Clamp(arg1,arg2,arg3);
9670     } catch (std::out_of_range& e) {
9671       {
9672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9673       };
9674     } catch (std::exception& e) {
9675       {
9676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9677       };
9678     } catch (...) {
9679       {
9680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9681       };
9682     }
9683   }
9684   jresult = new Dali::Radian((const Dali::Radian &)result);
9685   return jresult;
9686 }
9687
9688
9689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9690   void * jresult ;
9691   Dali::Quaternion *result = 0 ;
9692
9693   {
9694     try {
9695       result = (Dali::Quaternion *)new Dali::Quaternion();
9696     } catch (std::out_of_range& e) {
9697       {
9698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9699       };
9700     } catch (std::exception& e) {
9701       {
9702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9703       };
9704     } catch (...) {
9705       {
9706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9707       };
9708     }
9709   }
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9716   void * jresult ;
9717   Dali::Radian arg1 ;
9718   Dali::Vector3 *arg2 = 0 ;
9719   Dali::Radian *argp1 ;
9720   Dali::Quaternion *result = 0 ;
9721
9722   argp1 = (Dali::Radian *)jarg1;
9723   if (!argp1) {
9724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9725     return 0;
9726   }
9727   arg1 = *argp1;
9728   arg2 = (Dali::Vector3 *)jarg2;
9729   if (!arg2) {
9730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9731     return 0;
9732   }
9733   {
9734     try {
9735       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9736     } catch (std::out_of_range& e) {
9737       {
9738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (std::exception& e) {
9741       {
9742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9743       };
9744     } catch (...) {
9745       {
9746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9747       };
9748     }
9749   }
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9756   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9757
9758   arg1 = (Dali::Quaternion *)jarg1;
9759   {
9760     try {
9761       delete arg1;
9762     } catch (std::out_of_range& e) {
9763       {
9764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9765       };
9766     } catch (std::exception& e) {
9767       {
9768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9769       };
9770     } catch (...) {
9771       {
9772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9773       };
9774     }
9775   }
9776 }
9777
9778
9779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9780   void * jresult ;
9781   Dali::Quaternion *result = 0 ;
9782
9783   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9790   unsigned int jresult ;
9791   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9792   bool result;
9793
9794   arg1 = (Dali::Quaternion *)jarg1;
9795   {
9796     try {
9797       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9798     } catch (std::out_of_range& e) {
9799       {
9800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9801       };
9802     } catch (std::exception& e) {
9803       {
9804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9805       };
9806     } catch (...) {
9807       {
9808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9809       };
9810     }
9811   }
9812   jresult = result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9818   unsigned int jresult ;
9819   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9820   Dali::Vector3 *arg2 = 0 ;
9821   Dali::Radian *arg3 = 0 ;
9822   bool result;
9823
9824   arg1 = (Dali::Quaternion *)jarg1;
9825   arg2 = (Dali::Vector3 *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9828     return 0;
9829   }
9830   arg3 = (Dali::Radian *)jarg3;
9831   if (!arg3) {
9832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9833     return 0;
9834   }
9835   {
9836     try {
9837       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9838     } catch (std::out_of_range& e) {
9839       {
9840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (std::exception& e) {
9843       {
9844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9858   void * jresult ;
9859   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9860   Dali::Quaternion *arg2 = 0 ;
9861   Dali::Quaternion result;
9862
9863   arg1 = (Dali::Quaternion *)jarg1;
9864   arg2 = (Dali::Quaternion *)jarg2;
9865   if (!arg2) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9867     return 0;
9868   }
9869   {
9870     try {
9871       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9872     } catch (std::out_of_range& e) {
9873       {
9874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9875       };
9876     } catch (std::exception& e) {
9877       {
9878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (...) {
9881       {
9882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9883       };
9884     }
9885   }
9886   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9887   return jresult;
9888 }
9889
9890
9891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9892   void * jresult ;
9893   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9894   Dali::Quaternion *arg2 = 0 ;
9895   Dali::Quaternion result;
9896
9897   arg1 = (Dali::Quaternion *)jarg1;
9898   arg2 = (Dali::Quaternion *)jarg2;
9899   if (!arg2) {
9900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9901     return 0;
9902   }
9903   {
9904     try {
9905       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (...) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9917       };
9918     }
9919   }
9920   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9921   return jresult;
9922 }
9923
9924
9925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9926   void * jresult ;
9927   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9928   Dali::Quaternion *arg2 = 0 ;
9929   Dali::Quaternion result;
9930
9931   arg1 = (Dali::Quaternion *)jarg1;
9932   arg2 = (Dali::Quaternion *)jarg2;
9933   if (!arg2) {
9934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9935     return 0;
9936   }
9937   {
9938     try {
9939       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9940     } catch (std::out_of_range& e) {
9941       {
9942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (std::exception& e) {
9945       {
9946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9947       };
9948     } catch (...) {
9949       {
9950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9951       };
9952     }
9953   }
9954   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9955   return jresult;
9956 }
9957
9958
9959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9960   void * jresult ;
9961   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9962   Dali::Vector3 *arg2 = 0 ;
9963   Dali::Vector3 result;
9964
9965   arg1 = (Dali::Quaternion *)jarg1;
9966   arg2 = (Dali::Vector3 *)jarg2;
9967   if (!arg2) {
9968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9969     return 0;
9970   }
9971   {
9972     try {
9973       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9974     } catch (std::out_of_range& e) {
9975       {
9976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (std::exception& e) {
9979       {
9980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (...) {
9983       {
9984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9985       };
9986     }
9987   }
9988   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9989   return jresult;
9990 }
9991
9992
9993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9994   void * jresult ;
9995   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9996   Dali::Quaternion *arg2 = 0 ;
9997   Dali::Quaternion result;
9998
9999   arg1 = (Dali::Quaternion *)jarg1;
10000   arg2 = (Dali::Quaternion *)jarg2;
10001   if (!arg2) {
10002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10003     return 0;
10004   }
10005   {
10006     try {
10007       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10008     } catch (std::out_of_range& e) {
10009       {
10010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10011       };
10012     } catch (std::exception& e) {
10013       {
10014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10015       };
10016     } catch (...) {
10017       {
10018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10019       };
10020     }
10021   }
10022   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10023   return jresult;
10024 }
10025
10026
10027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10028   void * jresult ;
10029   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10030   float arg2 ;
10031   Dali::Quaternion result;
10032
10033   arg1 = (Dali::Quaternion *)jarg1;
10034   arg2 = (float)jarg2;
10035   {
10036     try {
10037       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10038     } catch (std::out_of_range& e) {
10039       {
10040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10041       };
10042     } catch (std::exception& e) {
10043       {
10044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10045       };
10046     } catch (...) {
10047       {
10048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10049       };
10050     }
10051   }
10052   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10053   return jresult;
10054 }
10055
10056
10057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10058   void * jresult ;
10059   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10060   float arg2 ;
10061   Dali::Quaternion result;
10062
10063   arg1 = (Dali::Quaternion *)jarg1;
10064   arg2 = (float)jarg2;
10065   {
10066     try {
10067       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10068     } catch (std::out_of_range& e) {
10069       {
10070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10071       };
10072     } catch (std::exception& e) {
10073       {
10074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10075       };
10076     } catch (...) {
10077       {
10078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10079       };
10080     }
10081   }
10082   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10083   return jresult;
10084 }
10085
10086
10087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10088   void * jresult ;
10089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10090   Dali::Quaternion result;
10091
10092   arg1 = (Dali::Quaternion *)jarg1;
10093   {
10094     try {
10095       result = ((Dali::Quaternion const *)arg1)->operator -();
10096     } catch (std::out_of_range& e) {
10097       {
10098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10099       };
10100     } catch (std::exception& e) {
10101       {
10102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (...) {
10105       {
10106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10107       };
10108     }
10109   }
10110   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10111   return jresult;
10112 }
10113
10114
10115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10116   void * jresult ;
10117   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10118   Dali::Quaternion *arg2 = 0 ;
10119   Dali::Quaternion *result = 0 ;
10120
10121   arg1 = (Dali::Quaternion *)jarg1;
10122   arg2 = (Dali::Quaternion *)jarg2;
10123   if (!arg2) {
10124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10125     return 0;
10126   }
10127   {
10128     try {
10129       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10130     } catch (std::out_of_range& e) {
10131       {
10132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (std::exception& e) {
10135       {
10136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (...) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10141       };
10142     }
10143   }
10144   jresult = (void *)result;
10145   return jresult;
10146 }
10147
10148
10149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10150   void * jresult ;
10151   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10152   Dali::Quaternion *arg2 = 0 ;
10153   Dali::Quaternion *result = 0 ;
10154
10155   arg1 = (Dali::Quaternion *)jarg1;
10156   arg2 = (Dali::Quaternion *)jarg2;
10157   if (!arg2) {
10158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10159     return 0;
10160   }
10161   {
10162     try {
10163       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10164     } catch (std::out_of_range& e) {
10165       {
10166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10167       };
10168     } catch (std::exception& e) {
10169       {
10170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10171       };
10172     } catch (...) {
10173       {
10174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10175       };
10176     }
10177   }
10178   jresult = (void *)result;
10179   return jresult;
10180 }
10181
10182
10183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10184   void * jresult ;
10185   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10186   Dali::Quaternion *arg2 = 0 ;
10187   Dali::Quaternion *result = 0 ;
10188
10189   arg1 = (Dali::Quaternion *)jarg1;
10190   arg2 = (Dali::Quaternion *)jarg2;
10191   if (!arg2) {
10192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10193     return 0;
10194   }
10195   {
10196     try {
10197       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10198     } catch (std::out_of_range& e) {
10199       {
10200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10201       };
10202     } catch (std::exception& e) {
10203       {
10204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10205       };
10206     } catch (...) {
10207       {
10208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10209       };
10210     }
10211   }
10212   jresult = (void *)result;
10213   return jresult;
10214 }
10215
10216
10217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10218   void * jresult ;
10219   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10220   float arg2 ;
10221   Dali::Quaternion *result = 0 ;
10222
10223   arg1 = (Dali::Quaternion *)jarg1;
10224   arg2 = (float)jarg2;
10225   {
10226     try {
10227       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10228     } catch (std::out_of_range& e) {
10229       {
10230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (std::exception& e) {
10233       {
10234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (...) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10239       };
10240     }
10241   }
10242   jresult = (void *)result;
10243   return jresult;
10244 }
10245
10246
10247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10248   void * jresult ;
10249   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10250   float arg2 ;
10251   Dali::Quaternion *result = 0 ;
10252
10253   arg1 = (Dali::Quaternion *)jarg1;
10254   arg2 = (float)jarg2;
10255   {
10256     try {
10257       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10258     } catch (std::out_of_range& e) {
10259       {
10260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10261       };
10262     } catch (std::exception& e) {
10263       {
10264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10265       };
10266     } catch (...) {
10267       {
10268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10269       };
10270     }
10271   }
10272   jresult = (void *)result;
10273   return jresult;
10274 }
10275
10276
10277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10278   unsigned int jresult ;
10279   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10280   Dali::Quaternion *arg2 = 0 ;
10281   bool result;
10282
10283   arg1 = (Dali::Quaternion *)jarg1;
10284   arg2 = (Dali::Quaternion *)jarg2;
10285   if (!arg2) {
10286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10287     return 0;
10288   }
10289   {
10290     try {
10291       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10292     } catch (std::out_of_range& e) {
10293       {
10294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10295       };
10296     } catch (std::exception& e) {
10297       {
10298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10299       };
10300     } catch (...) {
10301       {
10302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10303       };
10304     }
10305   }
10306   jresult = result;
10307   return jresult;
10308 }
10309
10310
10311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10312   unsigned int jresult ;
10313   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10314   Dali::Quaternion *arg2 = 0 ;
10315   bool result;
10316
10317   arg1 = (Dali::Quaternion *)jarg1;
10318   arg2 = (Dali::Quaternion *)jarg2;
10319   if (!arg2) {
10320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10321     return 0;
10322   }
10323   {
10324     try {
10325       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (...) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10337       };
10338     }
10339   }
10340   jresult = result;
10341   return jresult;
10342 }
10343
10344
10345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10346   float jresult ;
10347   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10348   float result;
10349
10350   arg1 = (Dali::Quaternion *)jarg1;
10351   {
10352     try {
10353       result = (float)((Dali::Quaternion const *)arg1)->Length();
10354     } catch (std::out_of_range& e) {
10355       {
10356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10357       };
10358     } catch (std::exception& e) {
10359       {
10360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (...) {
10363       {
10364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10365       };
10366     }
10367   }
10368   jresult = result;
10369   return jresult;
10370 }
10371
10372
10373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10374   float jresult ;
10375   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10376   float result;
10377
10378   arg1 = (Dali::Quaternion *)jarg1;
10379   {
10380     try {
10381       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10382     } catch (std::out_of_range& e) {
10383       {
10384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10385       };
10386     } catch (std::exception& e) {
10387       {
10388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10389       };
10390     } catch (...) {
10391       {
10392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10393       };
10394     }
10395   }
10396   jresult = result;
10397   return jresult;
10398 }
10399
10400
10401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10402   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10403
10404   arg1 = (Dali::Quaternion *)jarg1;
10405   {
10406     try {
10407       (arg1)->Normalize();
10408     } catch (std::out_of_range& e) {
10409       {
10410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10411       };
10412     } catch (std::exception& e) {
10413       {
10414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10415       };
10416     } catch (...) {
10417       {
10418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10419       };
10420     }
10421   }
10422 }
10423
10424
10425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10426   void * jresult ;
10427   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10428   Dali::Quaternion result;
10429
10430   arg1 = (Dali::Quaternion *)jarg1;
10431   {
10432     try {
10433       result = ((Dali::Quaternion const *)arg1)->Normalized();
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (...) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10445       };
10446     }
10447   }
10448   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10449   return jresult;
10450 }
10451
10452
10453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10454   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10455
10456   arg1 = (Dali::Quaternion *)jarg1;
10457   {
10458     try {
10459       (arg1)->Conjugate();
10460     } catch (std::out_of_range& e) {
10461       {
10462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10463       };
10464     } catch (std::exception& e) {
10465       {
10466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10467       };
10468     } catch (...) {
10469       {
10470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10471       };
10472     }
10473   }
10474 }
10475
10476
10477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10478   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10479
10480   arg1 = (Dali::Quaternion *)jarg1;
10481   {
10482     try {
10483       (arg1)->Invert();
10484     } catch (std::out_of_range& e) {
10485       {
10486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10487       };
10488     } catch (std::exception& e) {
10489       {
10490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10491       };
10492     } catch (...) {
10493       {
10494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10495       };
10496     }
10497   }
10498 }
10499
10500
10501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10502   void * jresult ;
10503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10504   Dali::Quaternion result;
10505
10506   arg1 = (Dali::Quaternion *)jarg1;
10507   {
10508     try {
10509       result = ((Dali::Quaternion const *)arg1)->Log();
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10525   return jresult;
10526 }
10527
10528
10529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10530   void * jresult ;
10531   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10532   Dali::Quaternion result;
10533
10534   arg1 = (Dali::Quaternion *)jarg1;
10535   {
10536     try {
10537       result = ((Dali::Quaternion const *)arg1)->Exp();
10538     } catch (std::out_of_range& e) {
10539       {
10540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10541       };
10542     } catch (std::exception& e) {
10543       {
10544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10545       };
10546     } catch (...) {
10547       {
10548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10549       };
10550     }
10551   }
10552   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10553   return jresult;
10554 }
10555
10556
10557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10558   float jresult ;
10559   Dali::Quaternion *arg1 = 0 ;
10560   Dali::Quaternion *arg2 = 0 ;
10561   float result;
10562
10563   arg1 = (Dali::Quaternion *)jarg1;
10564   if (!arg1) {
10565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10566     return 0;
10567   }
10568   arg2 = (Dali::Quaternion *)jarg2;
10569   if (!arg2) {
10570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10571     return 0;
10572   }
10573   {
10574     try {
10575       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10576     } catch (std::out_of_range& e) {
10577       {
10578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10579       };
10580     } catch (std::exception& e) {
10581       {
10582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10583       };
10584     } catch (...) {
10585       {
10586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10587       };
10588     }
10589   }
10590   jresult = result;
10591   return jresult;
10592 }
10593
10594
10595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10596   void * jresult ;
10597   Dali::Quaternion *arg1 = 0 ;
10598   Dali::Quaternion *arg2 = 0 ;
10599   float arg3 ;
10600   Dali::Quaternion result;
10601
10602   arg1 = (Dali::Quaternion *)jarg1;
10603   if (!arg1) {
10604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10605     return 0;
10606   }
10607   arg2 = (Dali::Quaternion *)jarg2;
10608   if (!arg2) {
10609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10610     return 0;
10611   }
10612   arg3 = (float)jarg3;
10613   {
10614     try {
10615       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10616     } catch (std::out_of_range& e) {
10617       {
10618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10619       };
10620     } catch (std::exception& e) {
10621       {
10622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10623       };
10624     } catch (...) {
10625       {
10626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10627       };
10628     }
10629   }
10630   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10631   return jresult;
10632 }
10633
10634
10635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10636   void * jresult ;
10637   Dali::Quaternion *arg1 = 0 ;
10638   Dali::Quaternion *arg2 = 0 ;
10639   float arg3 ;
10640   Dali::Quaternion result;
10641
10642   arg1 = (Dali::Quaternion *)jarg1;
10643   if (!arg1) {
10644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10645     return 0;
10646   }
10647   arg2 = (Dali::Quaternion *)jarg2;
10648   if (!arg2) {
10649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10650     return 0;
10651   }
10652   arg3 = (float)jarg3;
10653   {
10654     try {
10655       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10656     } catch (std::out_of_range& e) {
10657       {
10658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (std::exception& e) {
10661       {
10662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10676   void * jresult ;
10677   Dali::Quaternion *arg1 = 0 ;
10678   Dali::Quaternion *arg2 = 0 ;
10679   float arg3 ;
10680   Dali::Quaternion result;
10681
10682   arg1 = (Dali::Quaternion *)jarg1;
10683   if (!arg1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10685     return 0;
10686   }
10687   arg2 = (Dali::Quaternion *)jarg2;
10688   if (!arg2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10690     return 0;
10691   }
10692   arg3 = (float)jarg3;
10693   {
10694     try {
10695       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (...) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10707       };
10708     }
10709   }
10710   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10711   return jresult;
10712 }
10713
10714
10715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10716   void * jresult ;
10717   Dali::Quaternion *arg1 = 0 ;
10718   Dali::Quaternion *arg2 = 0 ;
10719   Dali::Quaternion *arg3 = 0 ;
10720   Dali::Quaternion *arg4 = 0 ;
10721   float arg5 ;
10722   Dali::Quaternion result;
10723
10724   arg1 = (Dali::Quaternion *)jarg1;
10725   if (!arg1) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10727     return 0;
10728   }
10729   arg2 = (Dali::Quaternion *)jarg2;
10730   if (!arg2) {
10731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10732     return 0;
10733   }
10734   arg3 = (Dali::Quaternion *)jarg3;
10735   if (!arg3) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10737     return 0;
10738   }
10739   arg4 = (Dali::Quaternion *)jarg4;
10740   if (!arg4) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10742     return 0;
10743   }
10744   arg5 = (float)jarg5;
10745   {
10746     try {
10747       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10748     } catch (std::out_of_range& e) {
10749       {
10750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10751       };
10752     } catch (std::exception& e) {
10753       {
10754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10755       };
10756     } catch (...) {
10757       {
10758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10759       };
10760     }
10761   }
10762   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10768   float jresult ;
10769   Dali::Quaternion *arg1 = 0 ;
10770   Dali::Quaternion *arg2 = 0 ;
10771   float result;
10772
10773   arg1 = (Dali::Quaternion *)jarg1;
10774   if (!arg1) {
10775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10776     return 0;
10777   }
10778   arg2 = (Dali::Quaternion *)jarg2;
10779   if (!arg2) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10781     return 0;
10782   }
10783   {
10784     try {
10785       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10786     } catch (std::out_of_range& e) {
10787       {
10788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (std::exception& e) {
10791       {
10792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800   jresult = result;
10801   return jresult;
10802 }
10803
10804
10805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10806   void * jresult ;
10807   Dali::Matrix *result = 0 ;
10808
10809   {
10810     try {
10811       result = (Dali::Matrix *)new Dali::Matrix();
10812     } catch (std::out_of_range& e) {
10813       {
10814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10815       };
10816     } catch (std::exception& e) {
10817       {
10818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10819       };
10820     } catch (...) {
10821       {
10822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10823       };
10824     }
10825   }
10826   jresult = (void *)result;
10827   return jresult;
10828 }
10829
10830
10831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10832   void * jresult ;
10833   bool arg1 ;
10834   Dali::Matrix *result = 0 ;
10835
10836   arg1 = jarg1 ? true : false;
10837   {
10838     try {
10839       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10840     } catch (std::out_of_range& e) {
10841       {
10842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10843       };
10844     } catch (std::exception& e) {
10845       {
10846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10847       };
10848     } catch (...) {
10849       {
10850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10851       };
10852     }
10853   }
10854   jresult = (void *)result;
10855   return jresult;
10856 }
10857
10858
10859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10860   void * jresult ;
10861   float *arg1 = (float *) 0 ;
10862   Dali::Matrix *result = 0 ;
10863
10864   arg1 = jarg1;
10865   {
10866     try {
10867       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10868     } catch (std::out_of_range& e) {
10869       {
10870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (std::exception& e) {
10873       {
10874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (...) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10879       };
10880     }
10881   }
10882   jresult = (void *)result;
10883
10884
10885   return jresult;
10886 }
10887
10888
10889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10890   void * jresult ;
10891   Dali::Quaternion *arg1 = 0 ;
10892   Dali::Matrix *result = 0 ;
10893
10894   arg1 = (Dali::Quaternion *)jarg1;
10895   if (!arg1) {
10896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10897     return 0;
10898   }
10899   {
10900     try {
10901       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10902     } catch (std::out_of_range& e) {
10903       {
10904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (std::exception& e) {
10907       {
10908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10922   void * jresult ;
10923   Dali::Matrix *arg1 = 0 ;
10924   Dali::Matrix *result = 0 ;
10925
10926   arg1 = (Dali::Matrix *)jarg1;
10927   if (!arg1) {
10928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10929     return 0;
10930   }
10931   {
10932     try {
10933       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10934     } catch (std::out_of_range& e) {
10935       {
10936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10937       };
10938     } catch (std::exception& e) {
10939       {
10940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10941       };
10942     } catch (...) {
10943       {
10944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10945       };
10946     }
10947   }
10948   jresult = (void *)result;
10949   return jresult;
10950 }
10951
10952
10953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10954   void * jresult ;
10955   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10956   Dali::Matrix *arg2 = 0 ;
10957   Dali::Matrix *result = 0 ;
10958
10959   arg1 = (Dali::Matrix *)jarg1;
10960   arg2 = (Dali::Matrix *)jarg2;
10961   if (!arg2) {
10962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10963     return 0;
10964   }
10965   {
10966     try {
10967       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10968     } catch (std::out_of_range& e) {
10969       {
10970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (std::exception& e) {
10973       {
10974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10975       };
10976     } catch (...) {
10977       {
10978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10979       };
10980     }
10981   }
10982   jresult = (void *)result;
10983   return jresult;
10984 }
10985
10986
10987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10988   void * jresult ;
10989   Dali::Matrix *result = 0 ;
10990
10991   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10992   jresult = (void *)result;
10993   return jresult;
10994 }
10995
10996
10997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10998   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10999
11000   arg1 = (Dali::Matrix *)jarg1;
11001   {
11002     try {
11003       (arg1)->SetIdentity();
11004     } catch (std::out_of_range& e) {
11005       {
11006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11007       };
11008     } catch (std::exception& e) {
11009       {
11010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11011       };
11012     } catch (...) {
11013       {
11014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11015       };
11016     }
11017   }
11018 }
11019
11020
11021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11022   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11023   Dali::Vector3 *arg2 = 0 ;
11024
11025   arg1 = (Dali::Matrix *)jarg1;
11026   arg2 = (Dali::Vector3 *)jarg2;
11027   if (!arg2) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11029     return ;
11030   }
11031   {
11032     try {
11033       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11045       };
11046     }
11047   }
11048 }
11049
11050
11051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11052   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11053   Dali::Matrix *arg2 = 0 ;
11054
11055   arg1 = (Dali::Matrix *)jarg1;
11056   arg2 = (Dali::Matrix *)jarg2;
11057   if (!arg2) {
11058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11059     return ;
11060   }
11061   {
11062     try {
11063       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11064     } catch (std::out_of_range& e) {
11065       {
11066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11067       };
11068     } catch (std::exception& e) {
11069       {
11070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11071       };
11072     } catch (...) {
11073       {
11074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11075       };
11076     }
11077   }
11078 }
11079
11080
11081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11082   unsigned int jresult ;
11083   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11084   bool result;
11085
11086   arg1 = (Dali::Matrix *)jarg1;
11087   {
11088     try {
11089       result = (bool)(arg1)->Invert();
11090     } catch (std::out_of_range& e) {
11091       {
11092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11093       };
11094     } catch (std::exception& e) {
11095       {
11096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11097       };
11098     } catch (...) {
11099       {
11100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11101       };
11102     }
11103   }
11104   jresult = result;
11105   return jresult;
11106 }
11107
11108
11109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11110   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11111
11112   arg1 = (Dali::Matrix *)jarg1;
11113   {
11114     try {
11115       (arg1)->Transpose();
11116     } catch (std::out_of_range& e) {
11117       {
11118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11119       };
11120     } catch (std::exception& e) {
11121       {
11122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11123       };
11124     } catch (...) {
11125       {
11126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11127       };
11128     }
11129   }
11130 }
11131
11132
11133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11134   void * jresult ;
11135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11136   Dali::Vector3 result;
11137
11138   arg1 = (Dali::Matrix *)jarg1;
11139   {
11140     try {
11141       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11142     } catch (std::out_of_range& e) {
11143       {
11144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11145       };
11146     } catch (std::exception& e) {
11147       {
11148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11149       };
11150     } catch (...) {
11151       {
11152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11153       };
11154     }
11155   }
11156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11157   return jresult;
11158 }
11159
11160
11161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11162   void * jresult ;
11163   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11164   Dali::Vector3 result;
11165
11166   arg1 = (Dali::Matrix *)jarg1;
11167   {
11168     try {
11169       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11170     } catch (std::out_of_range& e) {
11171       {
11172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (std::exception& e) {
11175       {
11176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11185   return jresult;
11186 }
11187
11188
11189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11190   void * jresult ;
11191   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11192   Dali::Vector3 result;
11193
11194   arg1 = (Dali::Matrix *)jarg1;
11195   {
11196     try {
11197       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11198     } catch (std::out_of_range& e) {
11199       {
11200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11201       };
11202     } catch (std::exception& e) {
11203       {
11204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11205       };
11206     } catch (...) {
11207       {
11208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11209       };
11210     }
11211   }
11212   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11213   return jresult;
11214 }
11215
11216
11217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11218   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11219   Dali::Vector3 *arg2 = 0 ;
11220
11221   arg1 = (Dali::Matrix *)jarg1;
11222   arg2 = (Dali::Vector3 *)jarg2;
11223   if (!arg2) {
11224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11225     return ;
11226   }
11227   {
11228     try {
11229       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11230     } catch (std::out_of_range& e) {
11231       {
11232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11233       };
11234     } catch (std::exception& e) {
11235       {
11236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11237       };
11238     } catch (...) {
11239       {
11240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11241       };
11242     }
11243   }
11244 }
11245
11246
11247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11248   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11249   Dali::Vector3 *arg2 = 0 ;
11250
11251   arg1 = (Dali::Matrix *)jarg1;
11252   arg2 = (Dali::Vector3 *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11255     return ;
11256   }
11257   {
11258     try {
11259       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11267       };
11268     } catch (...) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11271       };
11272     }
11273   }
11274 }
11275
11276
11277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11278   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11279   Dali::Vector3 *arg2 = 0 ;
11280
11281   arg1 = (Dali::Matrix *)jarg1;
11282   arg2 = (Dali::Vector3 *)jarg2;
11283   if (!arg2) {
11284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11285     return ;
11286   }
11287   {
11288     try {
11289       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11290     } catch (std::out_of_range& e) {
11291       {
11292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11293       };
11294     } catch (std::exception& e) {
11295       {
11296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11297       };
11298     } catch (...) {
11299       {
11300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11301       };
11302     }
11303   }
11304 }
11305
11306
11307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11308   void * jresult ;
11309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11310   Dali::Vector4 *result = 0 ;
11311
11312   arg1 = (Dali::Matrix *)jarg1;
11313   {
11314     try {
11315       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11316     } catch (std::out_of_range& e) {
11317       {
11318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11319       };
11320     } catch (std::exception& e) {
11321       {
11322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11323       };
11324     } catch (...) {
11325       {
11326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11327       };
11328     }
11329   }
11330   jresult = (void *)result;
11331   return jresult;
11332 }
11333
11334
11335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11336   void * jresult ;
11337   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11338   Dali::Vector3 *result = 0 ;
11339
11340   arg1 = (Dali::Matrix *)jarg1;
11341   {
11342     try {
11343       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11344     } catch (std::out_of_range& e) {
11345       {
11346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11347       };
11348     } catch (std::exception& e) {
11349       {
11350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11351       };
11352     } catch (...) {
11353       {
11354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11355       };
11356     }
11357   }
11358   jresult = (void *)result;
11359   return jresult;
11360 }
11361
11362
11363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11365   Dali::Vector4 *arg2 = 0 ;
11366
11367   arg1 = (Dali::Matrix *)jarg1;
11368   arg2 = (Dali::Vector4 *)jarg2;
11369   if (!arg2) {
11370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11371     return ;
11372   }
11373   {
11374     try {
11375       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11376     } catch (std::out_of_range& e) {
11377       {
11378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11379       };
11380     } catch (std::exception& e) {
11381       {
11382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11383       };
11384     } catch (...) {
11385       {
11386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11387       };
11388     }
11389   }
11390 }
11391
11392
11393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11394   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11395   Dali::Vector3 *arg2 = 0 ;
11396
11397   arg1 = (Dali::Matrix *)jarg1;
11398   arg2 = (Dali::Vector3 *)jarg2;
11399   if (!arg2) {
11400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11401     return ;
11402   }
11403   {
11404     try {
11405       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11406     } catch (std::out_of_range& e) {
11407       {
11408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11409       };
11410     } catch (std::exception& e) {
11411       {
11412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11417       };
11418     }
11419   }
11420 }
11421
11422
11423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11424   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11425
11426   arg1 = (Dali::Matrix *)jarg1;
11427   {
11428     try {
11429       (arg1)->OrthoNormalize();
11430     } catch (std::out_of_range& e) {
11431       {
11432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11433       };
11434     } catch (std::exception& e) {
11435       {
11436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11437       };
11438     } catch (...) {
11439       {
11440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11441       };
11442     }
11443   }
11444 }
11445
11446
11447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11448   void * jresult ;
11449   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11450   float *result = 0 ;
11451
11452   arg1 = (Dali::Matrix *)jarg1;
11453   {
11454     try {
11455       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11456     } catch (std::out_of_range& e) {
11457       {
11458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11459       };
11460     } catch (std::exception& e) {
11461       {
11462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11463       };
11464     } catch (...) {
11465       {
11466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11467       };
11468     }
11469   }
11470   jresult = (void *)result;
11471   return jresult;
11472 }
11473
11474
11475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11476   Dali::Matrix *arg1 = 0 ;
11477   Dali::Matrix *arg2 = 0 ;
11478   Dali::Matrix *arg3 = 0 ;
11479
11480   arg1 = (Dali::Matrix *)jarg1;
11481   if (!arg1) {
11482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11483     return ;
11484   }
11485   arg2 = (Dali::Matrix *)jarg2;
11486   if (!arg2) {
11487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11488     return ;
11489   }
11490   arg3 = (Dali::Matrix *)jarg3;
11491   if (!arg3) {
11492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11493     return ;
11494   }
11495   {
11496     try {
11497       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11498     } catch (std::out_of_range& e) {
11499       {
11500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11501       };
11502     } catch (std::exception& e) {
11503       {
11504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11505       };
11506     } catch (...) {
11507       {
11508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11509       };
11510     }
11511   }
11512 }
11513
11514
11515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11516   Dali::Matrix *arg1 = 0 ;
11517   Dali::Matrix *arg2 = 0 ;
11518   Dali::Quaternion *arg3 = 0 ;
11519
11520   arg1 = (Dali::Matrix *)jarg1;
11521   if (!arg1) {
11522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11523     return ;
11524   }
11525   arg2 = (Dali::Matrix *)jarg2;
11526   if (!arg2) {
11527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11528     return ;
11529   }
11530   arg3 = (Dali::Quaternion *)jarg3;
11531   if (!arg3) {
11532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11533     return ;
11534   }
11535   {
11536     try {
11537       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11538     } catch (std::out_of_range& e) {
11539       {
11540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11541       };
11542     } catch (std::exception& e) {
11543       {
11544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11545       };
11546     } catch (...) {
11547       {
11548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11549       };
11550     }
11551   }
11552 }
11553
11554
11555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11556   void * jresult ;
11557   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11558   Dali::Vector4 *arg2 = 0 ;
11559   Dali::Vector4 result;
11560
11561   arg1 = (Dali::Matrix *)jarg1;
11562   arg2 = (Dali::Vector4 *)jarg2;
11563   if (!arg2) {
11564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11565     return 0;
11566   }
11567   {
11568     try {
11569       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11570     } catch (std::out_of_range& e) {
11571       {
11572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11573       };
11574     } catch (std::exception& e) {
11575       {
11576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11577       };
11578     } catch (...) {
11579       {
11580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11581       };
11582     }
11583   }
11584   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11585   return jresult;
11586 }
11587
11588
11589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11590   unsigned int jresult ;
11591   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11592   Dali::Matrix *arg2 = 0 ;
11593   bool result;
11594
11595   arg1 = (Dali::Matrix *)jarg1;
11596   arg2 = (Dali::Matrix *)jarg2;
11597   if (!arg2) {
11598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11599     return 0;
11600   }
11601   {
11602     try {
11603       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11604     } catch (std::out_of_range& e) {
11605       {
11606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11607       };
11608     } catch (std::exception& e) {
11609       {
11610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11611       };
11612     } catch (...) {
11613       {
11614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11615       };
11616     }
11617   }
11618   jresult = result;
11619   return jresult;
11620 }
11621
11622
11623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11624   unsigned int jresult ;
11625   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11626   Dali::Matrix *arg2 = 0 ;
11627   bool result;
11628
11629   arg1 = (Dali::Matrix *)jarg1;
11630   arg2 = (Dali::Matrix *)jarg2;
11631   if (!arg2) {
11632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11633     return 0;
11634   }
11635   {
11636     try {
11637       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11638     } catch (std::out_of_range& e) {
11639       {
11640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11641       };
11642     } catch (std::exception& e) {
11643       {
11644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11645       };
11646     } catch (...) {
11647       {
11648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11649       };
11650     }
11651   }
11652   jresult = result;
11653   return jresult;
11654 }
11655
11656
11657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11658   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11659   Dali::Vector3 *arg2 = 0 ;
11660   Dali::Quaternion *arg3 = 0 ;
11661   Dali::Vector3 *arg4 = 0 ;
11662
11663   arg1 = (Dali::Matrix *)jarg1;
11664   arg2 = (Dali::Vector3 *)jarg2;
11665   if (!arg2) {
11666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11667     return ;
11668   }
11669   arg3 = (Dali::Quaternion *)jarg3;
11670   if (!arg3) {
11671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11672     return ;
11673   }
11674   arg4 = (Dali::Vector3 *)jarg4;
11675   if (!arg4) {
11676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11677     return ;
11678   }
11679   {
11680     try {
11681       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11682     } catch (std::out_of_range& e) {
11683       {
11684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11685       };
11686     } catch (std::exception& e) {
11687       {
11688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11693       };
11694     }
11695   }
11696 }
11697
11698
11699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11701   Dali::Vector3 *arg2 = 0 ;
11702   Dali::Quaternion *arg3 = 0 ;
11703   Dali::Vector3 *arg4 = 0 ;
11704
11705   arg1 = (Dali::Matrix *)jarg1;
11706   arg2 = (Dali::Vector3 *)jarg2;
11707   if (!arg2) {
11708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11709     return ;
11710   }
11711   arg3 = (Dali::Quaternion *)jarg3;
11712   if (!arg3) {
11713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11714     return ;
11715   }
11716   arg4 = (Dali::Vector3 *)jarg4;
11717   if (!arg4) {
11718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11719     return ;
11720   }
11721   {
11722     try {
11723       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11724     } catch (std::out_of_range& e) {
11725       {
11726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11727       };
11728     } catch (std::exception& e) {
11729       {
11730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11731       };
11732     } catch (...) {
11733       {
11734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11735       };
11736     }
11737   }
11738 }
11739
11740
11741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11742   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11743   Dali::Vector3 *arg2 = 0 ;
11744   Dali::Vector3 *arg3 = 0 ;
11745   Dali::Vector3 *arg4 = 0 ;
11746   Dali::Vector3 *arg5 = 0 ;
11747
11748   arg1 = (Dali::Matrix *)jarg1;
11749   arg2 = (Dali::Vector3 *)jarg2;
11750   if (!arg2) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11752     return ;
11753   }
11754   arg3 = (Dali::Vector3 *)jarg3;
11755   if (!arg3) {
11756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11757     return ;
11758   }
11759   arg4 = (Dali::Vector3 *)jarg4;
11760   if (!arg4) {
11761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11762     return ;
11763   }
11764   arg5 = (Dali::Vector3 *)jarg5;
11765   if (!arg5) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11767     return ;
11768   }
11769   {
11770     try {
11771       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11772     } catch (std::out_of_range& e) {
11773       {
11774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11775       };
11776     } catch (std::exception& e) {
11777       {
11778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11779       };
11780     } catch (...) {
11781       {
11782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11783       };
11784     }
11785   }
11786 }
11787
11788
11789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11790   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11791   Dali::Vector3 *arg2 = 0 ;
11792   Dali::Quaternion *arg3 = 0 ;
11793   Dali::Vector3 *arg4 = 0 ;
11794
11795   arg1 = (Dali::Matrix *)jarg1;
11796   arg2 = (Dali::Vector3 *)jarg2;
11797   if (!arg2) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11799     return ;
11800   }
11801   arg3 = (Dali::Quaternion *)jarg3;
11802   if (!arg3) {
11803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11804     return ;
11805   }
11806   arg4 = (Dali::Vector3 *)jarg4;
11807   if (!arg4) {
11808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11809     return ;
11810   }
11811   {
11812     try {
11813       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (...) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11825       };
11826     }
11827   }
11828 }
11829
11830
11831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11832   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11833
11834   arg1 = (Dali::Matrix *)jarg1;
11835   {
11836     try {
11837       delete arg1;
11838     } catch (std::out_of_range& e) {
11839       {
11840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11841       };
11842     } catch (std::exception& e) {
11843       {
11844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11845       };
11846     } catch (...) {
11847       {
11848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11849       };
11850     }
11851   }
11852 }
11853
11854
11855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11856   void * jresult ;
11857   Dali::Matrix3 *result = 0 ;
11858
11859   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11860   jresult = (void *)result;
11861   return jresult;
11862 }
11863
11864
11865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11866   void * jresult ;
11867   Dali::Matrix3 *result = 0 ;
11868
11869   {
11870     try {
11871       result = (Dali::Matrix3 *)new Dali::Matrix3();
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (...) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11883       };
11884     }
11885   }
11886   jresult = (void *)result;
11887   return jresult;
11888 }
11889
11890
11891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11892   void * jresult ;
11893   Dali::Matrix3 *arg1 = 0 ;
11894   Dali::Matrix3 *result = 0 ;
11895
11896   arg1 = (Dali::Matrix3 *)jarg1;
11897   if (!arg1) {
11898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11899     return 0;
11900   }
11901   {
11902     try {
11903       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11904     } catch (std::out_of_range& e) {
11905       {
11906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11907       };
11908     } catch (std::exception& e) {
11909       {
11910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11911       };
11912     } catch (...) {
11913       {
11914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11915       };
11916     }
11917   }
11918   jresult = (void *)result;
11919   return jresult;
11920 }
11921
11922
11923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11924   void * jresult ;
11925   Dali::Matrix *arg1 = 0 ;
11926   Dali::Matrix3 *result = 0 ;
11927
11928   arg1 = (Dali::Matrix *)jarg1;
11929   if (!arg1) {
11930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11931     return 0;
11932   }
11933   {
11934     try {
11935       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11936     } catch (std::out_of_range& e) {
11937       {
11938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11939       };
11940     } catch (std::exception& e) {
11941       {
11942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11943       };
11944     } catch (...) {
11945       {
11946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11947       };
11948     }
11949   }
11950   jresult = (void *)result;
11951   return jresult;
11952 }
11953
11954
11955 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) {
11956   void * jresult ;
11957   float arg1 ;
11958   float arg2 ;
11959   float arg3 ;
11960   float arg4 ;
11961   float arg5 ;
11962   float arg6 ;
11963   float arg7 ;
11964   float arg8 ;
11965   float arg9 ;
11966   Dali::Matrix3 *result = 0 ;
11967
11968   arg1 = (float)jarg1;
11969   arg2 = (float)jarg2;
11970   arg3 = (float)jarg3;
11971   arg4 = (float)jarg4;
11972   arg5 = (float)jarg5;
11973   arg6 = (float)jarg6;
11974   arg7 = (float)jarg7;
11975   arg8 = (float)jarg8;
11976   arg9 = (float)jarg9;
11977   {
11978     try {
11979       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (...) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11991       };
11992     }
11993   }
11994   jresult = (void *)result;
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12000   void * jresult ;
12001   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12002   Dali::Matrix3 *arg2 = 0 ;
12003   Dali::Matrix3 *result = 0 ;
12004
12005   arg1 = (Dali::Matrix3 *)jarg1;
12006   arg2 = (Dali::Matrix3 *)jarg2;
12007   if (!arg2) {
12008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12009     return 0;
12010   }
12011   {
12012     try {
12013       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12014     } catch (std::out_of_range& e) {
12015       {
12016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (std::exception& e) {
12019       {
12020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028   jresult = (void *)result;
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12034   void * jresult ;
12035   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12036   Dali::Matrix *arg2 = 0 ;
12037   Dali::Matrix3 *result = 0 ;
12038
12039   arg1 = (Dali::Matrix3 *)jarg1;
12040   arg2 = (Dali::Matrix *)jarg2;
12041   if (!arg2) {
12042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12043     return 0;
12044   }
12045   {
12046     try {
12047       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12048     } catch (std::out_of_range& e) {
12049       {
12050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12051       };
12052     } catch (std::exception& e) {
12053       {
12054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12055       };
12056     } catch (...) {
12057       {
12058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12059       };
12060     }
12061   }
12062   jresult = (void *)result;
12063   return jresult;
12064 }
12065
12066
12067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12068   unsigned int jresult ;
12069   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12070   Dali::Matrix3 *arg2 = 0 ;
12071   bool result;
12072
12073   arg1 = (Dali::Matrix3 *)jarg1;
12074   arg2 = (Dali::Matrix3 *)jarg2;
12075   if (!arg2) {
12076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12077     return 0;
12078   }
12079   {
12080     try {
12081       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12082     } catch (std::out_of_range& e) {
12083       {
12084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (std::exception& e) {
12087       {
12088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12089       };
12090     } catch (...) {
12091       {
12092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12093       };
12094     }
12095   }
12096   jresult = result;
12097   return jresult;
12098 }
12099
12100
12101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12102   unsigned int jresult ;
12103   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12104   Dali::Matrix3 *arg2 = 0 ;
12105   bool result;
12106
12107   arg1 = (Dali::Matrix3 *)jarg1;
12108   arg2 = (Dali::Matrix3 *)jarg2;
12109   if (!arg2) {
12110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12111     return 0;
12112   }
12113   {
12114     try {
12115       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12116     } catch (std::out_of_range& e) {
12117       {
12118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (std::exception& e) {
12121       {
12122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130   jresult = result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12136   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12137
12138   arg1 = (Dali::Matrix3 *)jarg1;
12139   {
12140     try {
12141       delete arg1;
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12149       };
12150     } catch (...) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12153       };
12154     }
12155   }
12156 }
12157
12158
12159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12160   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12161
12162   arg1 = (Dali::Matrix3 *)jarg1;
12163   {
12164     try {
12165       (arg1)->SetIdentity();
12166     } catch (std::out_of_range& e) {
12167       {
12168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12169       };
12170     } catch (std::exception& e) {
12171       {
12172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12173       };
12174     } catch (...) {
12175       {
12176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12177       };
12178     }
12179   }
12180 }
12181
12182
12183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12184   void * jresult ;
12185   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12186   float *result = 0 ;
12187
12188   arg1 = (Dali::Matrix3 *)jarg1;
12189   {
12190     try {
12191       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12192     } catch (std::out_of_range& e) {
12193       {
12194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (std::exception& e) {
12197       {
12198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (...) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12203       };
12204     }
12205   }
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12212   unsigned int jresult ;
12213   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12214   bool result;
12215
12216   arg1 = (Dali::Matrix3 *)jarg1;
12217   {
12218     try {
12219       result = (bool)(arg1)->Invert();
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (...) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12231       };
12232     }
12233   }
12234   jresult = result;
12235   return jresult;
12236 }
12237
12238
12239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12240   unsigned int jresult ;
12241   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12242   bool result;
12243
12244   arg1 = (Dali::Matrix3 *)jarg1;
12245   {
12246     try {
12247       result = (bool)(arg1)->Transpose();
12248     } catch (std::out_of_range& e) {
12249       {
12250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12251       };
12252     } catch (std::exception& e) {
12253       {
12254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (...) {
12257       {
12258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12259       };
12260     }
12261   }
12262   jresult = result;
12263   return jresult;
12264 }
12265
12266
12267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12268   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12269   float arg2 ;
12270
12271   arg1 = (Dali::Matrix3 *)jarg1;
12272   arg2 = (float)jarg2;
12273   {
12274     try {
12275       (arg1)->Scale(arg2);
12276     } catch (std::out_of_range& e) {
12277       {
12278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12279       };
12280     } catch (std::exception& e) {
12281       {
12282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12283       };
12284     } catch (...) {
12285       {
12286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12287       };
12288     }
12289   }
12290 }
12291
12292
12293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12294   float jresult ;
12295   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12296   float result;
12297
12298   arg1 = (Dali::Matrix3 *)jarg1;
12299   {
12300     try {
12301       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12302     } catch (std::out_of_range& e) {
12303       {
12304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12305       };
12306     } catch (std::exception& e) {
12307       {
12308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12309       };
12310     } catch (...) {
12311       {
12312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12313       };
12314     }
12315   }
12316   jresult = result;
12317   return jresult;
12318 }
12319
12320
12321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12322   unsigned int jresult ;
12323   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12324   bool result;
12325
12326   arg1 = (Dali::Matrix3 *)jarg1;
12327   {
12328     try {
12329       result = (bool)(arg1)->ScaledInverseTranspose();
12330     } catch (std::out_of_range& e) {
12331       {
12332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12333       };
12334     } catch (std::exception& e) {
12335       {
12336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12337       };
12338     } catch (...) {
12339       {
12340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12341       };
12342     }
12343   }
12344   jresult = result;
12345   return jresult;
12346 }
12347
12348
12349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12350   Dali::Matrix3 *arg1 = 0 ;
12351   Dali::Matrix3 *arg2 = 0 ;
12352   Dali::Matrix3 *arg3 = 0 ;
12353
12354   arg1 = (Dali::Matrix3 *)jarg1;
12355   if (!arg1) {
12356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12357     return ;
12358   }
12359   arg2 = (Dali::Matrix3 *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12362     return ;
12363   }
12364   arg3 = (Dali::Matrix3 *)jarg3;
12365   if (!arg3) {
12366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12367     return ;
12368   }
12369   {
12370     try {
12371       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12372     } catch (std::out_of_range& e) {
12373       {
12374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12375       };
12376     } catch (std::exception& e) {
12377       {
12378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12383       };
12384     }
12385   }
12386 }
12387
12388
12389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12390   float jresult ;
12391   float arg1 ;
12392   float arg2 ;
12393   float result;
12394
12395   arg1 = (float)jarg1;
12396   arg2 = (float)jarg2;
12397   {
12398     try {
12399       result = (float)Dali::Random::Range(arg1,arg2);
12400     } catch (std::out_of_range& e) {
12401       {
12402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12403       };
12404     } catch (std::exception& e) {
12405       {
12406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12407       };
12408     } catch (...) {
12409       {
12410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12411       };
12412     }
12413   }
12414   jresult = result;
12415   return jresult;
12416 }
12417
12418
12419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12420   void * jresult ;
12421   Dali::Vector4 result;
12422
12423   {
12424     try {
12425       result = Dali::Random::Axis();
12426     } catch (std::out_of_range& e) {
12427       {
12428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12429       };
12430     } catch (std::exception& e) {
12431       {
12432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12433       };
12434     } catch (...) {
12435       {
12436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12437       };
12438     }
12439   }
12440   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12441   return jresult;
12442 }
12443
12444
12445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12446   void * jresult ;
12447   Dali::AngleAxis *result = 0 ;
12448
12449   {
12450     try {
12451       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12452     } catch (std::out_of_range& e) {
12453       {
12454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12455       };
12456     } catch (std::exception& e) {
12457       {
12458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12463       };
12464     }
12465   }
12466   jresult = (void *)result;
12467   return jresult;
12468 }
12469
12470
12471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12472   void * jresult ;
12473   Dali::Radian arg1 ;
12474   Dali::Vector3 *arg2 = 0 ;
12475   Dali::Radian *argp1 ;
12476   Dali::AngleAxis *result = 0 ;
12477
12478   argp1 = (Dali::Radian *)jarg1;
12479   if (!argp1) {
12480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12481     return 0;
12482   }
12483   arg1 = *argp1;
12484   arg2 = (Dali::Vector3 *)jarg2;
12485   if (!arg2) {
12486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12487     return 0;
12488   }
12489   {
12490     try {
12491       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12492     } catch (std::out_of_range& e) {
12493       {
12494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12495       };
12496     } catch (std::exception& e) {
12497       {
12498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12499       };
12500     } catch (...) {
12501       {
12502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12503       };
12504     }
12505   }
12506   jresult = (void *)result;
12507   return jresult;
12508 }
12509
12510
12511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12512   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12513   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12514
12515   arg1 = (Dali::AngleAxis *)jarg1;
12516   arg2 = (Dali::Radian *)jarg2;
12517   if (arg1) (arg1)->angle = *arg2;
12518 }
12519
12520
12521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12522   void * jresult ;
12523   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12524   Dali::Radian *result = 0 ;
12525
12526   arg1 = (Dali::AngleAxis *)jarg1;
12527   result = (Dali::Radian *)& ((arg1)->angle);
12528   jresult = (void *)result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12534   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12535   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12536
12537   arg1 = (Dali::AngleAxis *)jarg1;
12538   arg2 = (Dali::Vector3 *)jarg2;
12539   if (arg1) (arg1)->axis = *arg2;
12540 }
12541
12542
12543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12544   void * jresult ;
12545   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12546   Dali::Vector3 *result = 0 ;
12547
12548   arg1 = (Dali::AngleAxis *)jarg1;
12549   result = (Dali::Vector3 *)& ((arg1)->axis);
12550   jresult = (void *)result;
12551   return jresult;
12552 }
12553
12554
12555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12556   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12557
12558   arg1 = (Dali::AngleAxis *)jarg1;
12559   {
12560     try {
12561       delete arg1;
12562     } catch (std::out_of_range& e) {
12563       {
12564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12565       };
12566     } catch (std::exception& e) {
12567       {
12568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12573       };
12574     }
12575   }
12576 }
12577
12578
12579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12580   unsigned int jresult ;
12581   Dali::AngleAxis *arg1 = 0 ;
12582   Dali::AngleAxis *arg2 = 0 ;
12583   bool result;
12584
12585   arg1 = (Dali::AngleAxis *)jarg1;
12586   if (!arg1) {
12587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12588     return 0;
12589   }
12590   arg2 = (Dali::AngleAxis *)jarg2;
12591   if (!arg2) {
12592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12593     return 0;
12594   }
12595   {
12596     try {
12597       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12598     } catch (std::out_of_range& e) {
12599       {
12600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12601       };
12602     } catch (std::exception& e) {
12603       {
12604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12605       };
12606     } catch (...) {
12607       {
12608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12609       };
12610     }
12611   }
12612   jresult = result;
12613   return jresult;
12614 }
12615
12616
12617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12618   unsigned int jresult ;
12619   unsigned int arg1 ;
12620   unsigned int result;
12621
12622   arg1 = (unsigned int)jarg1;
12623   {
12624     try {
12625       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12626     } catch (std::out_of_range& e) {
12627       {
12628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12629       };
12630     } catch (std::exception& e) {
12631       {
12632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12633       };
12634     } catch (...) {
12635       {
12636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12637       };
12638     }
12639   }
12640   jresult = result;
12641   return jresult;
12642 }
12643
12644
12645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12646   unsigned int jresult ;
12647   unsigned int arg1 ;
12648   bool result;
12649
12650   arg1 = (unsigned int)jarg1;
12651   {
12652     try {
12653       result = (bool)Dali::IsPowerOfTwo(arg1);
12654     } catch (std::out_of_range& e) {
12655       {
12656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12657       };
12658     } catch (std::exception& e) {
12659       {
12660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12661       };
12662     } catch (...) {
12663       {
12664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12665       };
12666     }
12667   }
12668   jresult = result;
12669   return jresult;
12670 }
12671
12672
12673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12674   float jresult ;
12675   float arg1 ;
12676   float arg2 ;
12677   float result;
12678
12679   arg1 = (float)jarg1;
12680   arg2 = (float)jarg2;
12681   {
12682     try {
12683       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12684     } catch (std::out_of_range& e) {
12685       {
12686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12687       };
12688     } catch (std::exception& e) {
12689       {
12690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12691       };
12692     } catch (...) {
12693       {
12694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12695       };
12696     }
12697   }
12698   jresult = result;
12699   return jresult;
12700 }
12701
12702
12703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12704   unsigned int jresult ;
12705   float arg1 ;
12706   bool result;
12707
12708   arg1 = (float)jarg1;
12709   {
12710     try {
12711       result = (bool)Dali::EqualsZero(arg1);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12719       };
12720     } catch (...) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12723       };
12724     }
12725   }
12726   jresult = result;
12727   return jresult;
12728 }
12729
12730
12731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12732   unsigned int jresult ;
12733   float arg1 ;
12734   float arg2 ;
12735   bool result;
12736
12737   arg1 = (float)jarg1;
12738   arg2 = (float)jarg2;
12739   {
12740     try {
12741       result = (bool)Dali::Equals(arg1,arg2);
12742     } catch (std::out_of_range& e) {
12743       {
12744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12745       };
12746     } catch (std::exception& e) {
12747       {
12748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12749       };
12750     } catch (...) {
12751       {
12752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12753       };
12754     }
12755   }
12756   jresult = result;
12757   return jresult;
12758 }
12759
12760
12761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12762   unsigned int jresult ;
12763   float arg1 ;
12764   float arg2 ;
12765   float arg3 ;
12766   bool result;
12767
12768   arg1 = (float)jarg1;
12769   arg2 = (float)jarg2;
12770   arg3 = (float)jarg3;
12771   {
12772     try {
12773       result = (bool)Dali::Equals(arg1,arg2,arg3);
12774     } catch (std::out_of_range& e) {
12775       {
12776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (std::exception& e) {
12779       {
12780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788   jresult = result;
12789   return jresult;
12790 }
12791
12792
12793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12794   float jresult ;
12795   float arg1 ;
12796   int arg2 ;
12797   float result;
12798
12799   arg1 = (float)jarg1;
12800   arg2 = (int)jarg2;
12801   {
12802     try {
12803       result = (float)Dali::Round(arg1,arg2);
12804     } catch (std::out_of_range& e) {
12805       {
12806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12807       };
12808     } catch (std::exception& e) {
12809       {
12810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (...) {
12813       {
12814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12815       };
12816     }
12817   }
12818   jresult = result;
12819   return jresult;
12820 }
12821
12822
12823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12824   float jresult ;
12825   float arg1 ;
12826   float arg2 ;
12827   float arg3 ;
12828   float result;
12829
12830   arg1 = (float)jarg1;
12831   arg2 = (float)jarg2;
12832   arg3 = (float)jarg3;
12833   {
12834     try {
12835       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12836     } catch (std::out_of_range& e) {
12837       {
12838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12839       };
12840     } catch (std::exception& e) {
12841       {
12842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12847       };
12848     }
12849   }
12850   jresult = result;
12851   return jresult;
12852 }
12853
12854
12855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12856   float jresult ;
12857   float arg1 ;
12858   float arg2 ;
12859   float arg3 ;
12860   float arg4 ;
12861   float result;
12862
12863   arg1 = (float)jarg1;
12864   arg2 = (float)jarg2;
12865   arg3 = (float)jarg3;
12866   arg4 = (float)jarg4;
12867   {
12868     try {
12869       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12870     } catch (std::out_of_range& e) {
12871       {
12872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12873       };
12874     } catch (std::exception& e) {
12875       {
12876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12877       };
12878     } catch (...) {
12879       {
12880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12881       };
12882     }
12883   }
12884   jresult = result;
12885   return jresult;
12886 }
12887
12888
12889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12890   int jresult ;
12891   int result;
12892
12893   result = (int)(int)Dali::Property::INVALID_INDEX;
12894   jresult = result;
12895   return jresult;
12896 }
12897
12898
12899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12900   int jresult ;
12901   int result;
12902
12903   result = (int)(int)Dali::Property::INVALID_KEY;
12904   jresult = result;
12905   return jresult;
12906 }
12907
12908
12909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12910   int jresult ;
12911   int result;
12912
12913   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12914   jresult = result;
12915   return jresult;
12916 }
12917
12918
12919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12920   void * jresult ;
12921   Dali::Handle *arg1 = 0 ;
12922   Dali::Property::Index arg2 ;
12923   Dali::Property *result = 0 ;
12924
12925   arg1 = (Dali::Handle *)jarg1;
12926   if (!arg1) {
12927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12928     return 0;
12929   }
12930   arg2 = (Dali::Property::Index)jarg2;
12931   {
12932     try {
12933       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12934     } catch (std::out_of_range& e) {
12935       {
12936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (std::exception& e) {
12939       {
12940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948   jresult = (void *)result;
12949   return jresult;
12950 }
12951
12952
12953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12954   void * jresult ;
12955   Dali::Handle *arg1 = 0 ;
12956   Dali::Property::Index arg2 ;
12957   int arg3 ;
12958   Dali::Property *result = 0 ;
12959
12960   arg1 = (Dali::Handle *)jarg1;
12961   if (!arg1) {
12962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12963     return 0;
12964   }
12965   arg2 = (Dali::Property::Index)jarg2;
12966   arg3 = (int)jarg3;
12967   {
12968     try {
12969       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12970     } catch (std::out_of_range& e) {
12971       {
12972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12973       };
12974     } catch (std::exception& e) {
12975       {
12976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12977       };
12978     } catch (...) {
12979       {
12980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12981       };
12982     }
12983   }
12984   jresult = (void *)result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12990   void * jresult ;
12991   Dali::Handle *arg1 = 0 ;
12992   std::string *arg2 = 0 ;
12993   Dali::Property *result = 0 ;
12994
12995   arg1 = (Dali::Handle *)jarg1;
12996   if (!arg1) {
12997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12998     return 0;
12999   }
13000   if (!jarg2) {
13001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13002     return 0;
13003   }
13004   std::string arg2_str(jarg2);
13005   arg2 = &arg2_str;
13006   {
13007     try {
13008       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13009     } catch (std::out_of_range& e) {
13010       {
13011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13012       };
13013     } catch (std::exception& e) {
13014       {
13015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13016       };
13017     } catch (...) {
13018       {
13019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13020       };
13021     }
13022   }
13023   jresult = (void *)result;
13024
13025   //argout typemap for const std::string&
13026
13027   return jresult;
13028 }
13029
13030
13031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13032   void * jresult ;
13033   Dali::Handle *arg1 = 0 ;
13034   std::string *arg2 = 0 ;
13035   int arg3 ;
13036   Dali::Property *result = 0 ;
13037
13038   arg1 = (Dali::Handle *)jarg1;
13039   if (!arg1) {
13040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13041     return 0;
13042   }
13043   if (!jarg2) {
13044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13045     return 0;
13046   }
13047   std::string arg2_str(jarg2);
13048   arg2 = &arg2_str;
13049   arg3 = (int)jarg3;
13050   {
13051     try {
13052       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13053     } catch (std::out_of_range& e) {
13054       {
13055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13056       };
13057     } catch (std::exception& e) {
13058       {
13059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13060       };
13061     } catch (...) {
13062       {
13063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13064       };
13065     }
13066   }
13067   jresult = (void *)result;
13068
13069   //argout typemap for const std::string&
13070
13071   return jresult;
13072 }
13073
13074
13075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13076   Dali::Property *arg1 = (Dali::Property *) 0 ;
13077
13078   arg1 = (Dali::Property *)jarg1;
13079   {
13080     try {
13081       delete arg1;
13082     } catch (std::out_of_range& e) {
13083       {
13084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13085       };
13086     } catch (std::exception& e) {
13087       {
13088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13089       };
13090     } catch (...) {
13091       {
13092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13093       };
13094     }
13095   }
13096 }
13097
13098
13099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13100   Dali::Property *arg1 = (Dali::Property *) 0 ;
13101   Dali::Handle *arg2 = 0 ;
13102
13103   arg1 = (Dali::Property *)jarg1;
13104   arg2 = (Dali::Handle *)jarg2;
13105   if (!arg2) {
13106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13107     return ;
13108   }
13109   if (arg1) (arg1)->object = *arg2;
13110 }
13111
13112
13113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13114   void * jresult ;
13115   Dali::Property *arg1 = (Dali::Property *) 0 ;
13116   Dali::Handle *result = 0 ;
13117
13118   arg1 = (Dali::Property *)jarg1;
13119   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13120   jresult = (void *)result;
13121   return jresult;
13122 }
13123
13124
13125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13126   Dali::Property *arg1 = (Dali::Property *) 0 ;
13127   Dali::Property::Index arg2 ;
13128
13129   arg1 = (Dali::Property *)jarg1;
13130   arg2 = (Dali::Property::Index)jarg2;
13131   if (arg1) (arg1)->propertyIndex = arg2;
13132 }
13133
13134
13135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13136   int jresult ;
13137   Dali::Property *arg1 = (Dali::Property *) 0 ;
13138   Dali::Property::Index result;
13139
13140   arg1 = (Dali::Property *)jarg1;
13141   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13142   jresult = result;
13143   return jresult;
13144 }
13145
13146
13147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13148   Dali::Property *arg1 = (Dali::Property *) 0 ;
13149   int arg2 ;
13150
13151   arg1 = (Dali::Property *)jarg1;
13152   arg2 = (int)jarg2;
13153   if (arg1) (arg1)->componentIndex = arg2;
13154 }
13155
13156
13157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13158   int jresult ;
13159   Dali::Property *arg1 = (Dali::Property *) 0 ;
13160   int result;
13161
13162   arg1 = (Dali::Property *)jarg1;
13163   result = (int) ((arg1)->componentIndex);
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13170   void * jresult ;
13171   Dali::Property::Array *result = 0 ;
13172
13173   {
13174     try {
13175       result = (Dali::Property::Array *)new Dali::Property::Array();
13176     } catch (std::out_of_range& e) {
13177       {
13178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13179       };
13180     } catch (std::exception& e) {
13181       {
13182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13183       };
13184     } catch (...) {
13185       {
13186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13187       };
13188     }
13189   }
13190   jresult = (void *)result;
13191   return jresult;
13192 }
13193
13194
13195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13196   void * jresult ;
13197   Dali::Property::Array *arg1 = 0 ;
13198   Dali::Property::Array *result = 0 ;
13199
13200   arg1 = (Dali::Property::Array *)jarg1;
13201   if (!arg1) {
13202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13203     return 0;
13204   }
13205   {
13206     try {
13207       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13208     } catch (std::out_of_range& e) {
13209       {
13210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13211       };
13212     } catch (std::exception& e) {
13213       {
13214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13215       };
13216     } catch (...) {
13217       {
13218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13219       };
13220     }
13221   }
13222   jresult = (void *)result;
13223   return jresult;
13224 }
13225
13226
13227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13228   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13229
13230   arg1 = (Dali::Property::Array *)jarg1;
13231   {
13232     try {
13233       delete arg1;
13234     } catch (std::out_of_range& e) {
13235       {
13236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13237       };
13238     } catch (std::exception& e) {
13239       {
13240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13241       };
13242     } catch (...) {
13243       {
13244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13245       };
13246     }
13247   }
13248 }
13249
13250
13251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13252   unsigned long jresult ;
13253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13254   Dali::Property::Array::SizeType result;
13255
13256   arg1 = (Dali::Property::Array *)jarg1;
13257   {
13258     try {
13259       result = ((Dali::Property::Array const *)arg1)->Size();
13260     } catch (std::out_of_range& e) {
13261       {
13262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13263       };
13264     } catch (std::exception& e) {
13265       {
13266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13267       };
13268     } catch (...) {
13269       {
13270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13271       };
13272     }
13273   }
13274   jresult = (unsigned long)result;
13275   return jresult;
13276 }
13277
13278
13279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13280   unsigned long jresult ;
13281   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13282   Dali::Property::Array::SizeType result;
13283
13284   arg1 = (Dali::Property::Array *)jarg1;
13285   {
13286     try {
13287       result = ((Dali::Property::Array const *)arg1)->Count();
13288     } catch (std::out_of_range& e) {
13289       {
13290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (std::exception& e) {
13293       {
13294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13295       };
13296     } catch (...) {
13297       {
13298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13299       };
13300     }
13301   }
13302   jresult = (unsigned long)result;
13303   return jresult;
13304 }
13305
13306
13307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13308   unsigned int jresult ;
13309   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13310   bool result;
13311
13312   arg1 = (Dali::Property::Array *)jarg1;
13313   {
13314     try {
13315       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13316     } catch (std::out_of_range& e) {
13317       {
13318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13319       };
13320     } catch (std::exception& e) {
13321       {
13322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13323       };
13324     } catch (...) {
13325       {
13326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13327       };
13328     }
13329   }
13330   jresult = result;
13331   return jresult;
13332 }
13333
13334
13335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13336   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13337
13338   arg1 = (Dali::Property::Array *)jarg1;
13339   {
13340     try {
13341       (arg1)->Clear();
13342     } catch (std::out_of_range& e) {
13343       {
13344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (std::exception& e) {
13347       {
13348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (...) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13353       };
13354     }
13355   }
13356 }
13357
13358
13359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13361   Dali::Property::Array::SizeType arg2 ;
13362
13363   arg1 = (Dali::Property::Array *)jarg1;
13364   arg2 = (Dali::Property::Array::SizeType)jarg2;
13365   {
13366     try {
13367       (arg1)->Reserve(arg2);
13368     } catch (std::out_of_range& e) {
13369       {
13370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13371       };
13372     } catch (std::exception& e) {
13373       {
13374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (...) {
13377       {
13378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13379       };
13380     }
13381   }
13382 }
13383
13384
13385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13386   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13387   Dali::Property::Array::SizeType arg2 ;
13388
13389   arg1 = (Dali::Property::Array *)jarg1;
13390   arg2 = (Dali::Property::Array::SizeType)jarg2;
13391   {
13392     try {
13393       (arg1)->Resize(arg2);
13394     } catch (std::out_of_range& e) {
13395       {
13396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13397       };
13398     } catch (std::exception& e) {
13399       {
13400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13401       };
13402     } catch (...) {
13403       {
13404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13405       };
13406     }
13407   }
13408 }
13409
13410
13411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13412   unsigned long jresult ;
13413   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13414   Dali::Property::Array::SizeType result;
13415
13416   arg1 = (Dali::Property::Array *)jarg1;
13417   {
13418     try {
13419       result = (arg1)->Capacity();
13420     } catch (std::out_of_range& e) {
13421       {
13422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13423       };
13424     } catch (std::exception& e) {
13425       {
13426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13427       };
13428     } catch (...) {
13429       {
13430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13431       };
13432     }
13433   }
13434   jresult = (unsigned long)result;
13435   return jresult;
13436 }
13437
13438
13439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13440   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13441   Dali::Property::Value *arg2 = 0 ;
13442
13443   arg1 = (Dali::Property::Array *)jarg1;
13444   arg2 = (Dali::Property::Value *)jarg2;
13445   if (!arg2) {
13446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13447     return ;
13448   }
13449   {
13450     try {
13451       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13452     } catch (std::out_of_range& e) {
13453       {
13454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13455       };
13456     } catch (std::exception& e) {
13457       {
13458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13463       };
13464     }
13465   }
13466 }
13467
13468
13469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13470   void * jresult ;
13471   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13472   Dali::Property::Value *arg2 = 0 ;
13473   Dali::Property::Array *result = 0 ;
13474
13475   arg1 = (Dali::Property::Array *)jarg1;
13476   arg2 = (Dali::Property::Value *)jarg2;
13477   if (!arg2) {
13478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13479     return 0;
13480   }
13481   {
13482     try {
13483       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13484     } catch (std::out_of_range& e) {
13485       {
13486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13487       };
13488     } catch (std::exception& e) {
13489       {
13490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (...) {
13493       {
13494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13495       };
13496     }
13497   }
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13504   void * jresult ;
13505   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13506   Dali::Property::Array::SizeType arg2 ;
13507   Dali::Property::Value *result = 0 ;
13508
13509   arg1 = (Dali::Property::Array *)jarg1;
13510   arg2 = (Dali::Property::Array::SizeType)jarg2;
13511   {
13512     try {
13513       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13514     } catch (std::out_of_range& e) {
13515       {
13516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13517       };
13518     } catch (std::exception& e) {
13519       {
13520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13521       };
13522     } catch (...) {
13523       {
13524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13525       };
13526     }
13527   }
13528   jresult = (void *)result;
13529   return jresult;
13530 }
13531
13532
13533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13534   void * jresult ;
13535   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13536   Dali::Property::Array::SizeType arg2 ;
13537   Dali::Property::Value *result = 0 ;
13538
13539   arg1 = (Dali::Property::Array *)jarg1;
13540   arg2 = (Dali::Property::Array::SizeType)jarg2;
13541   {
13542     try {
13543       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13544     } catch (std::out_of_range& e) {
13545       {
13546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13547       };
13548     } catch (std::exception& e) {
13549       {
13550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13551       };
13552     } catch (...) {
13553       {
13554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13555       };
13556     }
13557   }
13558   jresult = (void *)result;
13559   return jresult;
13560 }
13561
13562
13563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13564   void * jresult ;
13565   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13566   Dali::Property::Array *arg2 = 0 ;
13567   Dali::Property::Array *result = 0 ;
13568
13569   arg1 = (Dali::Property::Array *)jarg1;
13570   arg2 = (Dali::Property::Array *)jarg2;
13571   if (!arg2) {
13572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13573     return 0;
13574   }
13575   {
13576     try {
13577       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13578     } catch (std::out_of_range& e) {
13579       {
13580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (std::exception& e) {
13583       {
13584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13598   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13599   enum Dali::Property::Key::Type arg2 ;
13600
13601   arg1 = (Dali::Property::Key *)jarg1;
13602   arg2 = (enum Dali::Property::Key::Type)jarg2;
13603   if (arg1) (arg1)->type = arg2;
13604 }
13605
13606
13607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13608   int jresult ;
13609   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13610   enum Dali::Property::Key::Type result;
13611
13612   arg1 = (Dali::Property::Key *)jarg1;
13613   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13614   jresult = (int)result;
13615   return jresult;
13616 }
13617
13618
13619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13620   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13621   Dali::Property::Index arg2 ;
13622
13623   arg1 = (Dali::Property::Key *)jarg1;
13624   arg2 = (Dali::Property::Index)jarg2;
13625   if (arg1) (arg1)->indexKey = arg2;
13626 }
13627
13628
13629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13630   int jresult ;
13631   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13632   Dali::Property::Index result;
13633
13634   arg1 = (Dali::Property::Key *)jarg1;
13635   result = (Dali::Property::Index) ((arg1)->indexKey);
13636   jresult = result;
13637   return jresult;
13638 }
13639
13640
13641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13642   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13643   std::string *arg2 = 0 ;
13644
13645   arg1 = (Dali::Property::Key *)jarg1;
13646   if (!jarg2) {
13647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13648     return ;
13649   }
13650   std::string arg2_str(jarg2);
13651   arg2 = &arg2_str;
13652   if (arg1) (arg1)->stringKey = *arg2;
13653
13654   //argout typemap for const std::string&
13655
13656 }
13657
13658
13659 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13660   char * jresult ;
13661   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13662   std::string *result = 0 ;
13663
13664   arg1 = (Dali::Property::Key *)jarg1;
13665   result = (std::string *) & ((arg1)->stringKey);
13666   jresult = SWIG_csharp_string_callback(result->c_str());
13667   return jresult;
13668 }
13669
13670
13671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13672   void * jresult ;
13673   std::string *arg1 = 0 ;
13674   Dali::Property::Key *result = 0 ;
13675
13676   if (!jarg1) {
13677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13678     return 0;
13679   }
13680   std::string arg1_str(jarg1);
13681   arg1 = &arg1_str;
13682   {
13683     try {
13684       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13685     } catch (std::out_of_range& e) {
13686       {
13687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13688       };
13689     } catch (std::exception& e) {
13690       {
13691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13692       };
13693     } catch (...) {
13694       {
13695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13696       };
13697     }
13698   }
13699   jresult = (void *)result;
13700
13701   //argout typemap for const std::string&
13702
13703   return jresult;
13704 }
13705
13706
13707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13708   void * jresult ;
13709   Dali::Property::Index arg1 ;
13710   Dali::Property::Key *result = 0 ;
13711
13712   arg1 = (Dali::Property::Index)jarg1;
13713   {
13714     try {
13715       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13716     } catch (std::out_of_range& e) {
13717       {
13718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13719       };
13720     } catch (std::exception& e) {
13721       {
13722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13723       };
13724     } catch (...) {
13725       {
13726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13727       };
13728     }
13729   }
13730   jresult = (void *)result;
13731   return jresult;
13732 }
13733
13734
13735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13736   unsigned int jresult ;
13737   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13738   std::string *arg2 = 0 ;
13739   bool result;
13740
13741   arg1 = (Dali::Property::Key *)jarg1;
13742   if (!jarg2) {
13743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13744     return 0;
13745   }
13746   std::string arg2_str(jarg2);
13747   arg2 = &arg2_str;
13748   {
13749     try {
13750       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13758       };
13759     } catch (...) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13762       };
13763     }
13764   }
13765   jresult = result;
13766
13767   //argout typemap for const std::string&
13768
13769   return jresult;
13770 }
13771
13772
13773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13774   unsigned int jresult ;
13775   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13776   Dali::Property::Index arg2 ;
13777   bool result;
13778
13779   arg1 = (Dali::Property::Key *)jarg1;
13780   arg2 = (Dali::Property::Index)jarg2;
13781   {
13782     try {
13783       result = (bool)(arg1)->operator ==(arg2);
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (...) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13795       };
13796     }
13797   }
13798   jresult = result;
13799   return jresult;
13800 }
13801
13802
13803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13804   unsigned int jresult ;
13805   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13806   Dali::Property::Key *arg2 = 0 ;
13807   bool result;
13808
13809   arg1 = (Dali::Property::Key *)jarg1;
13810   arg2 = (Dali::Property::Key *)jarg2;
13811   if (!arg2) {
13812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13813     return 0;
13814   }
13815   {
13816     try {
13817       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13818     } catch (std::out_of_range& e) {
13819       {
13820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (std::exception& e) {
13823       {
13824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832   jresult = result;
13833   return jresult;
13834 }
13835
13836
13837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13838   unsigned int jresult ;
13839   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13840   std::string *arg2 = 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Property::Key *)jarg1;
13844   if (!jarg2) {
13845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13846     return 0;
13847   }
13848   std::string arg2_str(jarg2);
13849   arg2 = &arg2_str;
13850   {
13851     try {
13852       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13853     } catch (std::out_of_range& e) {
13854       {
13855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (std::exception& e) {
13858       {
13859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13860       };
13861     } catch (...) {
13862       {
13863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13864       };
13865     }
13866   }
13867   jresult = result;
13868
13869   //argout typemap for const std::string&
13870
13871   return jresult;
13872 }
13873
13874
13875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13876   unsigned int jresult ;
13877   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13878   Dali::Property::Index arg2 ;
13879   bool result;
13880
13881   arg1 = (Dali::Property::Key *)jarg1;
13882   arg2 = (Dali::Property::Index)jarg2;
13883   {
13884     try {
13885       result = (bool)(arg1)->operator !=(arg2);
13886     } catch (std::out_of_range& e) {
13887       {
13888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13889       };
13890     } catch (std::exception& e) {
13891       {
13892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13893       };
13894     } catch (...) {
13895       {
13896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13897       };
13898     }
13899   }
13900   jresult = result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13906   unsigned int jresult ;
13907   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13908   Dali::Property::Key *arg2 = 0 ;
13909   bool result;
13910
13911   arg1 = (Dali::Property::Key *)jarg1;
13912   arg2 = (Dali::Property::Key *)jarg2;
13913   if (!arg2) {
13914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13915     return 0;
13916   }
13917   {
13918     try {
13919       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13920     } catch (std::out_of_range& e) {
13921       {
13922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13923       };
13924     } catch (std::exception& e) {
13925       {
13926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13927       };
13928     } catch (...) {
13929       {
13930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13931       };
13932     }
13933   }
13934   jresult = result;
13935   return jresult;
13936 }
13937
13938
13939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13940   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13941
13942   arg1 = (Dali::Property::Key *)jarg1;
13943   {
13944     try {
13945       delete arg1;
13946     } catch (std::out_of_range& e) {
13947       {
13948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13949       };
13950     } catch (std::exception& e) {
13951       {
13952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13953       };
13954     } catch (...) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13957       };
13958     }
13959   }
13960 }
13961
13962
13963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13964   void * jresult ;
13965   Dali::Property::Map *result = 0 ;
13966
13967   {
13968     try {
13969       result = (Dali::Property::Map *)new Dali::Property::Map();
13970     } catch (std::out_of_range& e) {
13971       {
13972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13973       };
13974     } catch (std::exception& e) {
13975       {
13976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13977       };
13978     } catch (...) {
13979       {
13980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13981       };
13982     }
13983   }
13984   jresult = (void *)result;
13985   return jresult;
13986 }
13987
13988
13989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13990   void * jresult ;
13991   Dali::Property::Map *arg1 = 0 ;
13992   Dali::Property::Map *result = 0 ;
13993
13994   arg1 = (Dali::Property::Map *)jarg1;
13995   if (!arg1) {
13996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13997     return 0;
13998   }
13999   {
14000     try {
14001       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14002     } catch (std::out_of_range& e) {
14003       {
14004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14005       };
14006     } catch (std::exception& e) {
14007       {
14008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14009       };
14010     } catch (...) {
14011       {
14012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14013       };
14014     }
14015   }
14016   jresult = (void *)result;
14017   return jresult;
14018 }
14019
14020
14021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14022   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14023
14024   arg1 = (Dali::Property::Map *)jarg1;
14025   {
14026     try {
14027       delete arg1;
14028     } catch (std::out_of_range& e) {
14029       {
14030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14031       };
14032     } catch (std::exception& e) {
14033       {
14034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14039       };
14040     }
14041   }
14042 }
14043
14044
14045 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14046   unsigned long jresult ;
14047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14048   Dali::Property::Map::SizeType result;
14049
14050   arg1 = (Dali::Property::Map *)jarg1;
14051   {
14052     try {
14053       result = ((Dali::Property::Map const *)arg1)->Count();
14054     } catch (std::out_of_range& e) {
14055       {
14056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (std::exception& e) {
14059       {
14060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (...) {
14063       {
14064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14065       };
14066     }
14067   }
14068   jresult = (unsigned long)result;
14069   return jresult;
14070 }
14071
14072
14073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14074   unsigned int jresult ;
14075   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14076   bool result;
14077
14078   arg1 = (Dali::Property::Map *)jarg1;
14079   {
14080     try {
14081       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14082     } catch (std::out_of_range& e) {
14083       {
14084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14085       };
14086     } catch (std::exception& e) {
14087       {
14088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (...) {
14091       {
14092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14093       };
14094     }
14095   }
14096   jresult = result;
14097   return jresult;
14098 }
14099
14100
14101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14102   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14103   char *arg2 = (char *) 0 ;
14104   Dali::Property::Value *arg3 = 0 ;
14105
14106   arg1 = (Dali::Property::Map *)jarg1;
14107   arg2 = (char *)jarg2;
14108   arg3 = (Dali::Property::Value *)jarg3;
14109   if (!arg3) {
14110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14111     return ;
14112   }
14113   {
14114     try {
14115       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14116     } catch (std::out_of_range& e) {
14117       {
14118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14119       };
14120     } catch (std::exception& e) {
14121       {
14122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14123       };
14124     } catch (...) {
14125       {
14126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14127       };
14128     }
14129   }
14130 }
14131
14132
14133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14134   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14135   Dali::Property::Index arg2 ;
14136   Dali::Property::Value *arg3 = 0 ;
14137
14138   arg1 = (Dali::Property::Map *)jarg1;
14139   arg2 = (Dali::Property::Index)jarg2;
14140   arg3 = (Dali::Property::Value *)jarg3;
14141   if (!arg3) {
14142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14143     return ;
14144   }
14145   {
14146     try {
14147       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14148     } catch (std::out_of_range& e) {
14149       {
14150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14151       };
14152     } catch (std::exception& e) {
14153       {
14154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14155       };
14156     } catch (...) {
14157       {
14158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14159       };
14160     }
14161   }
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14166   void * jresult ;
14167   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14168   char *arg2 = (char *) 0 ;
14169   Dali::Property::Value *arg3 = 0 ;
14170   Dali::Property::Map *result = 0 ;
14171
14172   arg1 = (Dali::Property::Map *)jarg1;
14173   arg2 = (char *)jarg2;
14174   arg3 = (Dali::Property::Value *)jarg3;
14175   if (!arg3) {
14176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14177     return 0;
14178   }
14179   {
14180     try {
14181       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14182     } catch (std::out_of_range& e) {
14183       {
14184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14185       };
14186     } catch (std::exception& e) {
14187       {
14188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14189       };
14190     } catch (...) {
14191       {
14192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14193       };
14194     }
14195   }
14196   jresult = (void *)result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14202   void * jresult ;
14203   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14204   Dali::Property::Index arg2 ;
14205   Dali::Property::Value *arg3 = 0 ;
14206   Dali::Property::Map *result = 0 ;
14207
14208   arg1 = (Dali::Property::Map *)jarg1;
14209   arg2 = (Dali::Property::Index)jarg2;
14210   arg3 = (Dali::Property::Value *)jarg3;
14211   if (!arg3) {
14212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14213     return 0;
14214   }
14215   {
14216     try {
14217       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14218     } catch (std::out_of_range& e) {
14219       {
14220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14221       };
14222     } catch (std::exception& e) {
14223       {
14224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14225       };
14226     } catch (...) {
14227       {
14228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14229       };
14230     }
14231   }
14232   jresult = (void *)result;
14233   return jresult;
14234 }
14235
14236
14237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14238   void * jresult ;
14239   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14240   Dali::Property::Map::SizeType arg2 ;
14241   Dali::Property::Value *result = 0 ;
14242
14243   arg1 = (Dali::Property::Map *)jarg1;
14244   arg2 = (Dali::Property::Map::SizeType)jarg2;
14245   {
14246     try {
14247       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14259       };
14260     }
14261   }
14262   jresult = (void *)result;
14263   return jresult;
14264 }
14265
14266
14267 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14268   char * jresult ;
14269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14270   Dali::Property::Map::SizeType arg2 ;
14271   std::string *result = 0 ;
14272
14273   arg1 = (Dali::Property::Map *)jarg1;
14274   arg2 = (Dali::Property::Map::SizeType)jarg2;
14275   {
14276     try {
14277       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14278     } catch (std::out_of_range& e) {
14279       {
14280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14281       };
14282     } catch (std::exception& e) {
14283       {
14284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (...) {
14287       {
14288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14289       };
14290     }
14291   }
14292   jresult = SWIG_csharp_string_callback(result->c_str());
14293   return jresult;
14294 }
14295
14296
14297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14298   void * jresult ;
14299   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14300   Dali::Property::Map::SizeType arg2 ;
14301   SwigValueWrapper< Dali::Property::Key > result;
14302
14303   arg1 = (Dali::Property::Map *)jarg1;
14304   arg2 = (Dali::Property::Map::SizeType)jarg2;
14305   {
14306     try {
14307       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14308     } catch (std::out_of_range& e) {
14309       {
14310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (std::exception& e) {
14313       {
14314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14315       };
14316     } catch (...) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14319       };
14320     }
14321   }
14322   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14328   void * jresult ;
14329   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14330   Dali::Property::Map::SizeType arg2 ;
14331   StringValuePair *result = 0 ;
14332
14333   arg1 = (Dali::Property::Map *)jarg1;
14334   arg2 = (Dali::Property::Map::SizeType)jarg2;
14335   {
14336     try {
14337       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14338     } catch (std::out_of_range& e) {
14339       {
14340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14341       };
14342     } catch (std::exception& e) {
14343       {
14344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14345       };
14346     } catch (...) {
14347       {
14348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14349       };
14350     }
14351   }
14352   jresult = (void *)result;
14353   return jresult;
14354 }
14355
14356
14357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14358   void * jresult ;
14359   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14360   char *arg2 = (char *) 0 ;
14361   Dali::Property::Value *result = 0 ;
14362
14363   arg1 = (Dali::Property::Map *)jarg1;
14364   arg2 = (char *)jarg2;
14365   {
14366     try {
14367       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14368     } catch (std::out_of_range& e) {
14369       {
14370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14371       };
14372     } catch (std::exception& e) {
14373       {
14374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (...) {
14377       {
14378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14379       };
14380     }
14381   }
14382   jresult = (void *)result;
14383   return jresult;
14384 }
14385
14386
14387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14388   void * jresult ;
14389   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14390   Dali::Property::Index arg2 ;
14391   Dali::Property::Value *result = 0 ;
14392
14393   arg1 = (Dali::Property::Map *)jarg1;
14394   arg2 = (Dali::Property::Index)jarg2;
14395   {
14396     try {
14397       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14398     } catch (std::out_of_range& e) {
14399       {
14400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14401       };
14402     } catch (std::exception& e) {
14403       {
14404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14405       };
14406     } catch (...) {
14407       {
14408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14409       };
14410     }
14411   }
14412   jresult = (void *)result;
14413   return jresult;
14414 }
14415
14416
14417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14418   void * jresult ;
14419   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14420   Dali::Property::Index arg2 ;
14421   std::string *arg3 = 0 ;
14422   Dali::Property::Value *result = 0 ;
14423
14424   arg1 = (Dali::Property::Map *)jarg1;
14425   arg2 = (Dali::Property::Index)jarg2;
14426   if (!jarg3) {
14427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14428     return 0;
14429   }
14430   std::string arg3_str(jarg3);
14431   arg3 = &arg3_str;
14432   {
14433     try {
14434       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14435     } catch (std::out_of_range& e) {
14436       {
14437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14438       };
14439     } catch (std::exception& e) {
14440       {
14441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14442       };
14443     } catch (...) {
14444       {
14445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14446       };
14447     }
14448   }
14449   jresult = (void *)result;
14450
14451   //argout typemap for const std::string&
14452
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   std::string *arg2 = 0 ;
14461   Dali::Property::Type arg3 ;
14462   Dali::Property::Value *result = 0 ;
14463
14464   arg1 = (Dali::Property::Map *)jarg1;
14465   if (!jarg2) {
14466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14467     return 0;
14468   }
14469   std::string arg2_str(jarg2);
14470   arg2 = &arg2_str;
14471   arg3 = (Dali::Property::Type)jarg3;
14472   {
14473     try {
14474       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (...) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14486       };
14487     }
14488   }
14489   jresult = (void *)result;
14490
14491   //argout typemap for const std::string&
14492
14493   return jresult;
14494 }
14495
14496
14497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14498   void * jresult ;
14499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14500   Dali::Property::Index arg2 ;
14501   Dali::Property::Type arg3 ;
14502   Dali::Property::Value *result = 0 ;
14503
14504   arg1 = (Dali::Property::Map *)jarg1;
14505   arg2 = (Dali::Property::Index)jarg2;
14506   arg3 = (Dali::Property::Type)jarg3;
14507   {
14508     try {
14509       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14510     } catch (std::out_of_range& e) {
14511       {
14512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14513       };
14514     } catch (std::exception& e) {
14515       {
14516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14517       };
14518     } catch (...) {
14519       {
14520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14521       };
14522     }
14523   }
14524   jresult = (void *)result;
14525   return jresult;
14526 }
14527
14528
14529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14531
14532   arg1 = (Dali::Property::Map *)jarg1;
14533   {
14534     try {
14535       (arg1)->Clear();
14536     } catch (std::out_of_range& e) {
14537       {
14538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14539       };
14540     } catch (std::exception& e) {
14541       {
14542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14543       };
14544     } catch (...) {
14545       {
14546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14547       };
14548     }
14549   }
14550 }
14551
14552
14553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14554   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14555   Dali::Property::Map *arg2 = 0 ;
14556
14557   arg1 = (Dali::Property::Map *)jarg1;
14558   arg2 = (Dali::Property::Map *)jarg2;
14559   if (!arg2) {
14560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14561     return ;
14562   }
14563   {
14564     try {
14565       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14566     } catch (std::out_of_range& e) {
14567       {
14568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14569       };
14570     } catch (std::exception& e) {
14571       {
14572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14573       };
14574     } catch (...) {
14575       {
14576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14577       };
14578     }
14579   }
14580 }
14581
14582
14583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14584   void * jresult ;
14585   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14586   std::string *arg2 = 0 ;
14587   Dali::Property::Value *result = 0 ;
14588
14589   arg1 = (Dali::Property::Map *)jarg1;
14590   if (!jarg2) {
14591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14592     return 0;
14593   }
14594   std::string arg2_str(jarg2);
14595   arg2 = &arg2_str;
14596   {
14597     try {
14598       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14599     } catch (std::out_of_range& e) {
14600       {
14601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14602       };
14603     } catch (std::exception& e) {
14604       {
14605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14606       };
14607     } catch (...) {
14608       {
14609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14610       };
14611     }
14612   }
14613   jresult = (void *)result;
14614
14615   //argout typemap for const std::string&
14616
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property::Value *result = 0 ;
14626
14627   arg1 = (Dali::Property::Map *)jarg1;
14628   arg2 = (Dali::Property::Index)jarg2;
14629   {
14630     try {
14631       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14632     } catch (std::out_of_range& e) {
14633       {
14634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (std::exception& e) {
14637       {
14638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646   jresult = (void *)result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14652   void * jresult ;
14653   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14654   Dali::Property::Map *arg2 = 0 ;
14655   Dali::Property::Map *result = 0 ;
14656
14657   arg1 = (Dali::Property::Map *)jarg1;
14658   arg2 = (Dali::Property::Map *)jarg2;
14659   if (!arg2) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14661     return 0;
14662   }
14663   {
14664     try {
14665       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14677       };
14678     }
14679   }
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14686   void * jresult ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   {
14690     try {
14691       result = (Dali::Property::Value *)new Dali::Property::Value();
14692     } catch (std::out_of_range& e) {
14693       {
14694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14695       };
14696     } catch (std::exception& e) {
14697       {
14698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14699       };
14700     } catch (...) {
14701       {
14702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14703       };
14704     }
14705   }
14706   jresult = (void *)result;
14707   return jresult;
14708 }
14709
14710
14711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14712   void * jresult ;
14713   bool arg1 ;
14714   Dali::Property::Value *result = 0 ;
14715
14716   arg1 = jarg1 ? true : false;
14717   {
14718     try {
14719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14720     } catch (std::out_of_range& e) {
14721       {
14722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (std::exception& e) {
14725       {
14726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14727       };
14728     } catch (...) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14731       };
14732     }
14733   }
14734   jresult = (void *)result;
14735   return jresult;
14736 }
14737
14738
14739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14740   void * jresult ;
14741   int arg1 ;
14742   Dali::Property::Value *result = 0 ;
14743
14744   arg1 = (int)jarg1;
14745   {
14746     try {
14747       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14748     } catch (std::out_of_range& e) {
14749       {
14750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14751       };
14752     } catch (std::exception& e) {
14753       {
14754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14755       };
14756     } catch (...) {
14757       {
14758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14759       };
14760     }
14761   }
14762   jresult = (void *)result;
14763   return jresult;
14764 }
14765
14766
14767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14768   void * jresult ;
14769   float arg1 ;
14770   Dali::Property::Value *result = 0 ;
14771
14772   arg1 = (float)jarg1;
14773   {
14774     try {
14775       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14776     } catch (std::out_of_range& e) {
14777       {
14778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14779       };
14780     } catch (std::exception& e) {
14781       {
14782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14783       };
14784     } catch (...) {
14785       {
14786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14787       };
14788     }
14789   }
14790   jresult = (void *)result;
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14796   void * jresult ;
14797   Dali::Vector2 *arg1 = 0 ;
14798   Dali::Property::Value *result = 0 ;
14799
14800   arg1 = (Dali::Vector2 *)jarg1;
14801   if (!arg1) {
14802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14803     return 0;
14804   }
14805   {
14806     try {
14807       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14808     } catch (std::out_of_range& e) {
14809       {
14810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14811       };
14812     } catch (std::exception& e) {
14813       {
14814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14819       };
14820     }
14821   }
14822   jresult = (void *)result;
14823   return jresult;
14824 }
14825
14826
14827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14828   void * jresult ;
14829   Dali::Vector3 *arg1 = 0 ;
14830   Dali::Property::Value *result = 0 ;
14831
14832   arg1 = (Dali::Vector3 *)jarg1;
14833   if (!arg1) {
14834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14835     return 0;
14836   }
14837   {
14838     try {
14839       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14840     } catch (std::out_of_range& e) {
14841       {
14842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14843       };
14844     } catch (std::exception& e) {
14845       {
14846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14847       };
14848     } catch (...) {
14849       {
14850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14851       };
14852     }
14853   }
14854   jresult = (void *)result;
14855   return jresult;
14856 }
14857
14858
14859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14860   void * jresult ;
14861   Dali::Vector4 *arg1 = 0 ;
14862   Dali::Property::Value *result = 0 ;
14863
14864   arg1 = (Dali::Vector4 *)jarg1;
14865   if (!arg1) {
14866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14867     return 0;
14868   }
14869   {
14870     try {
14871       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14872     } catch (std::out_of_range& e) {
14873       {
14874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14875       };
14876     } catch (std::exception& e) {
14877       {
14878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14879       };
14880     } catch (...) {
14881       {
14882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14883       };
14884     }
14885   }
14886   jresult = (void *)result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14892   void * jresult ;
14893   Dali::Matrix3 *arg1 = 0 ;
14894   Dali::Property::Value *result = 0 ;
14895
14896   arg1 = (Dali::Matrix3 *)jarg1;
14897   if (!arg1) {
14898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14899     return 0;
14900   }
14901   {
14902     try {
14903       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14904     } catch (std::out_of_range& e) {
14905       {
14906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (std::exception& e) {
14909       {
14910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918   jresult = (void *)result;
14919   return jresult;
14920 }
14921
14922
14923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14924   void * jresult ;
14925   Dali::Matrix *arg1 = 0 ;
14926   Dali::Property::Value *result = 0 ;
14927
14928   arg1 = (Dali::Matrix *)jarg1;
14929   if (!arg1) {
14930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14931     return 0;
14932   }
14933   {
14934     try {
14935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14936     } catch (std::out_of_range& e) {
14937       {
14938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14939       };
14940     } catch (std::exception& e) {
14941       {
14942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (...) {
14945       {
14946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14947       };
14948     }
14949   }
14950   jresult = (void *)result;
14951   return jresult;
14952 }
14953
14954
14955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14956   void * jresult ;
14957   Dali::Rect< int > *arg1 = 0 ;
14958   Dali::Property::Value *result = 0 ;
14959
14960   arg1 = (Dali::Rect< int > *)jarg1;
14961   if (!arg1) {
14962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14963     return 0;
14964   }
14965   {
14966     try {
14967       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14975       };
14976     } catch (...) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14979       };
14980     }
14981   }
14982   jresult = (void *)result;
14983   return jresult;
14984 }
14985
14986
14987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14988   void * jresult ;
14989   Dali::AngleAxis *arg1 = 0 ;
14990   Dali::Property::Value *result = 0 ;
14991
14992   arg1 = (Dali::AngleAxis *)jarg1;
14993   if (!arg1) {
14994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14995     return 0;
14996   }
14997   {
14998     try {
14999       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (...) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15011       };
15012     }
15013   }
15014   jresult = (void *)result;
15015   return jresult;
15016 }
15017
15018
15019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15020   void * jresult ;
15021   Dali::Quaternion *arg1 = 0 ;
15022   Dali::Property::Value *result = 0 ;
15023
15024   arg1 = (Dali::Quaternion *)jarg1;
15025   if (!arg1) {
15026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15027     return 0;
15028   }
15029   {
15030     try {
15031       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (...) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15043       };
15044     }
15045   }
15046   jresult = (void *)result;
15047   return jresult;
15048 }
15049
15050
15051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15052   void * jresult ;
15053   std::string *arg1 = 0 ;
15054   Dali::Property::Value *result = 0 ;
15055
15056   if (!jarg1) {
15057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15058     return 0;
15059   }
15060   std::string arg1_str(jarg1);
15061   arg1 = &arg1_str;
15062   {
15063     try {
15064       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (...) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15076       };
15077     }
15078   }
15079   jresult = (void *)result;
15080
15081   //argout typemap for const std::string&
15082
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15088   void * jresult ;
15089   Dali::Property::Array *arg1 = 0 ;
15090   Dali::Property::Value *result = 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   if (!arg1) {
15094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15095     return 0;
15096   }
15097   {
15098     try {
15099       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15100     } catch (std::out_of_range& e) {
15101       {
15102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15103       };
15104     } catch (std::exception& e) {
15105       {
15106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15111       };
15112     }
15113   }
15114   jresult = (void *)result;
15115   return jresult;
15116 }
15117
15118
15119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15120   void * jresult ;
15121   Dali::Property::Map *arg1 = 0 ;
15122   Dali::Property::Value *result = 0 ;
15123
15124   arg1 = (Dali::Property::Map *)jarg1;
15125   if (!arg1) {
15126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15127     return 0;
15128   }
15129   {
15130     try {
15131       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15132     } catch (std::out_of_range& e) {
15133       {
15134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15135       };
15136     } catch (std::exception& e) {
15137       {
15138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15143       };
15144     }
15145   }
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15152   void * jresult ;
15153   Dali::Property::Type arg1 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   arg1 = (Dali::Property::Type)jarg1;
15157   {
15158     try {
15159       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15160     } catch (std::out_of_range& e) {
15161       {
15162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15163       };
15164     } catch (std::exception& e) {
15165       {
15166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15167       };
15168     } catch (...) {
15169       {
15170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15171       };
15172     }
15173   }
15174   jresult = (void *)result;
15175   return jresult;
15176 }
15177
15178
15179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15180   void * jresult ;
15181   Dali::Property::Value *arg1 = 0 ;
15182   Dali::Property::Value *result = 0 ;
15183
15184   arg1 = (Dali::Property::Value *)jarg1;
15185   if (!arg1) {
15186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15187     return 0;
15188   }
15189   {
15190     try {
15191       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (...) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15203       };
15204     }
15205   }
15206   jresult = (void *)result;
15207   return jresult;
15208 }
15209
15210
15211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15212   void * jresult ;
15213   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15214   Dali::Property::Value *arg2 = 0 ;
15215   Dali::Property::Value *result = 0 ;
15216
15217   arg1 = (Dali::Property::Value *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return 0;
15222   }
15223   {
15224     try {
15225       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15233       };
15234     } catch (...) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15237       };
15238     }
15239   }
15240   jresult = (void *)result;
15241   return jresult;
15242 }
15243
15244
15245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15246   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15247
15248   arg1 = (Dali::Property::Value *)jarg1;
15249   {
15250     try {
15251       delete arg1;
15252     } catch (std::out_of_range& e) {
15253       {
15254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15255       };
15256     } catch (std::exception& e) {
15257       {
15258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15259       };
15260     } catch (...) {
15261       {
15262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15263       };
15264     }
15265   }
15266 }
15267
15268
15269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15270   int jresult ;
15271   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15272   Dali::Property::Type result;
15273
15274   arg1 = (Dali::Property::Value *)jarg1;
15275   {
15276     try {
15277       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15278     } catch (std::out_of_range& e) {
15279       {
15280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15281       };
15282     } catch (std::exception& e) {
15283       {
15284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15285       };
15286     } catch (...) {
15287       {
15288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15289       };
15290     }
15291   }
15292   jresult = (int)result;
15293   return jresult;
15294 }
15295
15296
15297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15298   unsigned int jresult ;
15299   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15300   bool *arg2 = 0 ;
15301   bool result;
15302
15303   arg1 = (Dali::Property::Value *)jarg1;
15304   arg2 = (bool *)jarg2;
15305   {
15306     try {
15307       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15308     } catch (std::out_of_range& e) {
15309       {
15310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15311       };
15312     } catch (std::exception& e) {
15313       {
15314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15315       };
15316     } catch (...) {
15317       {
15318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15319       };
15320     }
15321   }
15322   jresult = result;
15323   return jresult;
15324 }
15325
15326
15327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15328   unsigned int jresult ;
15329   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15330   float *arg2 = 0 ;
15331   bool result;
15332
15333   arg1 = (Dali::Property::Value *)jarg1;
15334   arg2 = (float *)jarg2;
15335   {
15336     try {
15337       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15338     } catch (std::out_of_range& e) {
15339       {
15340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (std::exception& e) {
15343       {
15344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352   jresult = result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15358   unsigned int jresult ;
15359   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15360   int *arg2 = 0 ;
15361   bool result;
15362
15363   arg1 = (Dali::Property::Value *)jarg1;
15364   arg2 = (int *)jarg2;
15365   {
15366     try {
15367       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15368     } catch (std::out_of_range& e) {
15369       {
15370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15371       };
15372     } catch (std::exception& e) {
15373       {
15374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (...) {
15377       {
15378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15379       };
15380     }
15381   }
15382   jresult = result;
15383   return jresult;
15384 }
15385
15386
15387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15388   unsigned int jresult ;
15389   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15390   Dali::Rect< int > *arg2 = 0 ;
15391   bool result;
15392
15393   arg1 = (Dali::Property::Value *)jarg1;
15394   arg2 = (Dali::Rect< int > *)jarg2;
15395   if (!arg2) {
15396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15397     return 0;
15398   }
15399   {
15400     try {
15401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15402     } catch (std::out_of_range& e) {
15403       {
15404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15405       };
15406     } catch (std::exception& e) {
15407       {
15408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15409       };
15410     } catch (...) {
15411       {
15412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15413       };
15414     }
15415   }
15416   jresult = result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15422   unsigned int jresult ;
15423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15424   Dali::Vector2 *arg2 = 0 ;
15425   bool result;
15426
15427   arg1 = (Dali::Property::Value *)jarg1;
15428   arg2 = (Dali::Vector2 *)jarg2;
15429   if (!arg2) {
15430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15431     return 0;
15432   }
15433   {
15434     try {
15435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15436     } catch (std::out_of_range& e) {
15437       {
15438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15439       };
15440     } catch (std::exception& e) {
15441       {
15442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (...) {
15445       {
15446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15447       };
15448     }
15449   }
15450   jresult = result;
15451   return jresult;
15452 }
15453
15454
15455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15456   unsigned int jresult ;
15457   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15458   Dali::Vector3 *arg2 = 0 ;
15459   bool result;
15460
15461   arg1 = (Dali::Property::Value *)jarg1;
15462   arg2 = (Dali::Vector3 *)jarg2;
15463   if (!arg2) {
15464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15465     return 0;
15466   }
15467   {
15468     try {
15469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15470     } catch (std::out_of_range& e) {
15471       {
15472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15473       };
15474     } catch (std::exception& e) {
15475       {
15476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (...) {
15479       {
15480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15481       };
15482     }
15483   }
15484   jresult = result;
15485   return jresult;
15486 }
15487
15488
15489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15490   unsigned int jresult ;
15491   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15492   Dali::Vector4 *arg2 = 0 ;
15493   bool result;
15494
15495   arg1 = (Dali::Property::Value *)jarg1;
15496   arg2 = (Dali::Vector4 *)jarg2;
15497   if (!arg2) {
15498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15499     return 0;
15500   }
15501   {
15502     try {
15503       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15504     } catch (std::out_of_range& e) {
15505       {
15506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15507       };
15508     } catch (std::exception& e) {
15509       {
15510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15511       };
15512     } catch (...) {
15513       {
15514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15515       };
15516     }
15517   }
15518   jresult = result;
15519   return jresult;
15520 }
15521
15522
15523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15524   unsigned int jresult ;
15525   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15526   Dali::Matrix3 *arg2 = 0 ;
15527   bool result;
15528
15529   arg1 = (Dali::Property::Value *)jarg1;
15530   arg2 = (Dali::Matrix3 *)jarg2;
15531   if (!arg2) {
15532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15533     return 0;
15534   }
15535   {
15536     try {
15537       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15538     } catch (std::out_of_range& e) {
15539       {
15540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15541       };
15542     } catch (std::exception& e) {
15543       {
15544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15545       };
15546     } catch (...) {
15547       {
15548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15549       };
15550     }
15551   }
15552   jresult = result;
15553   return jresult;
15554 }
15555
15556
15557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15558   unsigned int jresult ;
15559   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15560   Dali::Matrix *arg2 = 0 ;
15561   bool result;
15562
15563   arg1 = (Dali::Property::Value *)jarg1;
15564   arg2 = (Dali::Matrix *)jarg2;
15565   if (!arg2) {
15566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15567     return 0;
15568   }
15569   {
15570     try {
15571       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15572     } catch (std::out_of_range& e) {
15573       {
15574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (std::exception& e) {
15577       {
15578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586   jresult = result;
15587   return jresult;
15588 }
15589
15590
15591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15592   unsigned int jresult ;
15593   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15594   Dali::AngleAxis *arg2 = 0 ;
15595   bool result;
15596
15597   arg1 = (Dali::Property::Value *)jarg1;
15598   arg2 = (Dali::AngleAxis *)jarg2;
15599   if (!arg2) {
15600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15601     return 0;
15602   }
15603   {
15604     try {
15605       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15606     } catch (std::out_of_range& e) {
15607       {
15608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15609       };
15610     } catch (std::exception& e) {
15611       {
15612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15613       };
15614     } catch (...) {
15615       {
15616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15617       };
15618     }
15619   }
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15628   Dali::Quaternion *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Value *)jarg1;
15632   arg2 = (Dali::Quaternion *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (...) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15651       };
15652     }
15653   }
15654   jresult = result;
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15660   unsigned int jresult ;
15661   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15662   std::string *arg2 = 0 ;
15663   bool result;
15664
15665   arg1 = (Dali::Property::Value *)jarg1;
15666
15667   //typemap in
15668   std::string temp;
15669   arg2 = &temp;
15670
15671   {
15672     try {
15673       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15674     } catch (std::out_of_range& e) {
15675       {
15676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (std::exception& e) {
15679       {
15680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (...) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15685       };
15686     }
15687   }
15688   jresult = result;
15689
15690   //Typemap argout in c++ file.
15691   //This will convert c++ string to c# string
15692   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15693
15694   return jresult;
15695 }
15696
15697
15698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15699   unsigned int jresult ;
15700   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15701   Dali::Property::Array *arg2 = 0 ;
15702   bool result;
15703
15704   arg1 = (Dali::Property::Value *)jarg1;
15705   arg2 = (Dali::Property::Array *)jarg2;
15706   if (!arg2) {
15707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15708     return 0;
15709   }
15710   {
15711     try {
15712       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15713     } catch (std::out_of_range& e) {
15714       {
15715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (std::exception& e) {
15718       {
15719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (...) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15724       };
15725     }
15726   }
15727   jresult = result;
15728   return jresult;
15729 }
15730
15731
15732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15733   unsigned int jresult ;
15734   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15735   Dali::Property::Map *arg2 = 0 ;
15736   bool result;
15737
15738   arg1 = (Dali::Property::Value *)jarg1;
15739   arg2 = (Dali::Property::Map *)jarg2;
15740   if (!arg2) {
15741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15742     return 0;
15743   }
15744   {
15745     try {
15746       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15747     } catch (std::out_of_range& e) {
15748       {
15749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15750       };
15751     } catch (std::exception& e) {
15752       {
15753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (...) {
15756       {
15757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15758       };
15759     }
15760   }
15761   jresult = result;
15762   return jresult;
15763 }
15764
15765
15766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15767   void * jresult ;
15768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15769   Dali::Property::Array *result = 0 ;
15770
15771   arg1 = (Dali::Property::Value *)jarg1;
15772   {
15773     try {
15774       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15775     } catch (std::out_of_range& e) {
15776       {
15777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15778       };
15779     } catch (std::exception& e) {
15780       {
15781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15782       };
15783     } catch (...) {
15784       {
15785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15786       };
15787     }
15788   }
15789   jresult = (void *)result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15795   void * jresult ;
15796   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15797   Dali::Property::Map *result = 0 ;
15798
15799   arg1 = (Dali::Property::Value *)jarg1;
15800   {
15801     try {
15802       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15803     } catch (std::out_of_range& e) {
15804       {
15805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15806       };
15807     } catch (std::exception& e) {
15808       {
15809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (...) {
15812       {
15813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15814       };
15815     }
15816   }
15817   jresult = (void *)result;
15818   return jresult;
15819 }
15820
15821
15822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15823   char * jresult ;
15824   Dali::Property::Type arg1 ;
15825   char *result = 0 ;
15826
15827   arg1 = (Dali::Property::Type)jarg1;
15828   {
15829     try {
15830       result = (char *)Dali::PropertyTypes::GetName(arg1);
15831     } catch (std::out_of_range& e) {
15832       {
15833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15834       };
15835     } catch (std::exception& e) {
15836       {
15837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15838       };
15839     } catch (...) {
15840       {
15841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15842       };
15843     }
15844   }
15845   jresult = SWIG_csharp_string_callback((const char *)result);
15846   return jresult;
15847 }
15848
15849
15850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15851   unsigned int jresult ;
15852   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15853   std::string *arg2 = 0 ;
15854   Dali::Property::Map *arg3 = 0 ;
15855   bool result;
15856
15857   arg1 = (Dali::BaseObject *)jarg1;
15858   if (!jarg2) {
15859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15860     return 0;
15861   }
15862   std::string arg2_str(jarg2);
15863   arg2 = &arg2_str;
15864   arg3 = (Dali::Property::Map *)jarg3;
15865   if (!arg3) {
15866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15867     return 0;
15868   }
15869   {
15870     try {
15871       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15872     } catch (std::out_of_range& e) {
15873       {
15874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15875       };
15876     } catch (std::exception& e) {
15877       {
15878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15879       };
15880     } catch (...) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15883       };
15884     }
15885   }
15886   jresult = result;
15887
15888   //argout typemap for const std::string&
15889
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15895   char * jresult ;
15896   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15897   std::string *result = 0 ;
15898
15899   arg1 = (Dali::BaseObject *)jarg1;
15900   {
15901     try {
15902       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (...) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15914       };
15915     }
15916   }
15917   jresult = SWIG_csharp_string_callback(result->c_str());
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15923   unsigned int jresult ;
15924   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15925   Dali::TypeInfo *arg2 = 0 ;
15926   bool result;
15927
15928   arg1 = (Dali::BaseObject *)jarg1;
15929   arg2 = (Dali::TypeInfo *)jarg2;
15930   if (!arg2) {
15931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15932     return 0;
15933   }
15934   {
15935     try {
15936       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15937     } catch (std::out_of_range& e) {
15938       {
15939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15940       };
15941     } catch (std::exception& e) {
15942       {
15943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15944       };
15945     } catch (...) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15948       };
15949     }
15950   }
15951   jresult = result;
15952   return jresult;
15953 }
15954
15955
15956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15957   unsigned int jresult ;
15958   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15959   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15960   std::string *arg3 = 0 ;
15961   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15962   bool result;
15963
15964   arg1 = (Dali::BaseObject *)jarg1;
15965   arg2 = (ConnectionTrackerInterface *)jarg2;
15966   if (!jarg3) {
15967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15968     return 0;
15969   }
15970   std::string arg3_str(jarg3);
15971   arg3 = &arg3_str;
15972   arg4 = (FunctorDelegate *)jarg4;
15973   {
15974     try {
15975       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15976     } catch (std::out_of_range& e) {
15977       {
15978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (std::exception& e) {
15981       {
15982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15983       };
15984     } catch (...) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15987       };
15988     }
15989   }
15990   jresult = result;
15991
15992   //argout typemap for const std::string&
15993
15994   return jresult;
15995 }
15996
15997
15998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15999   void * jresult ;
16000   Dali::BaseHandle *arg1 = 0 ;
16001   Dali::BaseObject *result = 0 ;
16002
16003   arg1 = (Dali::BaseHandle *)jarg1;
16004   if (!arg1) {
16005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16006     return 0;
16007   }
16008   {
16009     try {
16010       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16011     } catch (std::out_of_range& e) {
16012       {
16013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16014       };
16015     } catch (std::exception& e) {
16016       {
16017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16018       };
16019     } catch (...) {
16020       {
16021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16022       };
16023     }
16024   }
16025   jresult = (void *)result;
16026   return jresult;
16027 }
16028
16029
16030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16031   void * jresult ;
16032   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16033   Dali::BaseHandle *result = 0 ;
16034
16035   arg1 = (Dali::BaseObject *)jarg1;
16036   {
16037     try {
16038       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16039     } catch (std::out_of_range& e) {
16040       {
16041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16042       };
16043     } catch (std::exception& e) {
16044       {
16045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16046       };
16047     } catch (...) {
16048       {
16049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16050       };
16051     }
16052   }
16053   jresult = (void *)result;
16054   return jresult;
16055 }
16056
16057
16058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16059   void * jresult ;
16060   Dali::BaseHandle *result = 0 ;
16061
16062   {
16063     try {
16064       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16065     } catch (std::out_of_range& e) {
16066       {
16067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (std::exception& e) {
16070       {
16071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079   jresult = (void *)result;
16080   return jresult;
16081 }
16082
16083
16084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16085   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16086
16087   arg1 = (Dali::BaseHandle *)jarg1;
16088   {
16089     try {
16090       delete arg1;
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16098       };
16099     } catch (...) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16102       };
16103     }
16104   }
16105 }
16106
16107
16108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16109   void * jresult ;
16110   Dali::BaseHandle *arg1 = 0 ;
16111   Dali::BaseHandle *result = 0 ;
16112
16113   arg1 = (Dali::BaseHandle *)jarg1;
16114   if (!arg1) {
16115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16116     return 0;
16117   }
16118   {
16119     try {
16120       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16121     } catch (std::out_of_range& e) {
16122       {
16123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16124       };
16125     } catch (std::exception& e) {
16126       {
16127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16128       };
16129     } catch (...) {
16130       {
16131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16132       };
16133     }
16134   }
16135   jresult = (void *)result;
16136   return jresult;
16137 }
16138
16139
16140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16141   void * jresult ;
16142   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16143   Dali::BaseHandle *arg2 = 0 ;
16144   Dali::BaseHandle *result = 0 ;
16145
16146   arg1 = (Dali::BaseHandle *)jarg1;
16147   arg2 = (Dali::BaseHandle *)jarg2;
16148   if (!arg2) {
16149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16150     return 0;
16151   }
16152   {
16153     try {
16154       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16155     } catch (std::out_of_range& e) {
16156       {
16157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16158       };
16159     } catch (std::exception& e) {
16160       {
16161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16162       };
16163     } catch (...) {
16164       {
16165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16166       };
16167     }
16168   }
16169   jresult = (void *)result;
16170   return jresult;
16171 }
16172
16173
16174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16175   unsigned int jresult ;
16176   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16177   std::string *arg2 = 0 ;
16178   Dali::Property::Map *arg3 = 0 ;
16179   bool result;
16180
16181   arg1 = (Dali::BaseHandle *)jarg1;
16182   if (!jarg2) {
16183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16184     return 0;
16185   }
16186   std::string arg2_str(jarg2);
16187   arg2 = &arg2_str;
16188   arg3 = (Dali::Property::Map *)jarg3;
16189   if (!arg3) {
16190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16191     return 0;
16192   }
16193   {
16194     try {
16195       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16196     } catch (std::out_of_range& e) {
16197       {
16198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16199       };
16200     } catch (std::exception& e) {
16201       {
16202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16203       };
16204     } catch (...) {
16205       {
16206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16207       };
16208     }
16209   }
16210   jresult = result;
16211
16212   //argout typemap for const std::string&
16213
16214   return jresult;
16215 }
16216
16217
16218 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16219   char * jresult ;
16220   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16221   std::string *result = 0 ;
16222
16223   arg1 = (Dali::BaseHandle *)jarg1;
16224   {
16225     try {
16226       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16227     } catch (std::out_of_range& e) {
16228       {
16229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16230       };
16231     } catch (std::exception& e) {
16232       {
16233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16234       };
16235     } catch (...) {
16236       {
16237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16238       };
16239     }
16240   }
16241   jresult = SWIG_csharp_string_callback(result->c_str());
16242   return jresult;
16243 }
16244
16245
16246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16247   unsigned int jresult ;
16248   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16249   Dali::TypeInfo *arg2 = 0 ;
16250   bool result;
16251
16252   arg1 = (Dali::BaseHandle *)jarg1;
16253   arg2 = (Dali::TypeInfo *)jarg2;
16254   if (!arg2) {
16255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16256     return 0;
16257   }
16258   {
16259     try {
16260       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16261     } catch (std::out_of_range& e) {
16262       {
16263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16264       };
16265     } catch (std::exception& e) {
16266       {
16267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16268       };
16269     } catch (...) {
16270       {
16271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16272       };
16273     }
16274   }
16275   jresult = result;
16276   return jresult;
16277 }
16278
16279
16280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16281   void * jresult ;
16282   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16283   Dali::BaseObject *result = 0 ;
16284
16285   arg1 = (Dali::BaseHandle *)jarg1;
16286   {
16287     try {
16288       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16289     } catch (std::out_of_range& e) {
16290       {
16291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16292       };
16293     } catch (std::exception& e) {
16294       {
16295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16296       };
16297     } catch (...) {
16298       {
16299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16300       };
16301     }
16302   }
16303   jresult = (void *)result;
16304   return jresult;
16305 }
16306
16307
16308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16309   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16310
16311   arg1 = (Dali::BaseHandle *)jarg1;
16312   {
16313     try {
16314       (arg1)->Reset();
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16322       };
16323     } catch (...) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16326       };
16327     }
16328   }
16329 }
16330
16331
16332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16333   unsigned int jresult ;
16334   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16335   Dali::BaseHandle *arg2 = 0 ;
16336   bool result;
16337
16338   arg1 = (Dali::BaseHandle *)jarg1;
16339   arg2 = (Dali::BaseHandle *)jarg2;
16340   if (!arg2) {
16341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16342     return 0;
16343   }
16344   {
16345     try {
16346       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16347     } catch (std::out_of_range& e) {
16348       {
16349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16350       };
16351     } catch (std::exception& e) {
16352       {
16353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (...) {
16356       {
16357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16358       };
16359     }
16360   }
16361   jresult = result;
16362   return jresult;
16363 }
16364
16365
16366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16367   unsigned int jresult ;
16368   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16369   Dali::BaseHandle *arg2 = 0 ;
16370   bool result;
16371
16372   arg1 = (Dali::BaseHandle *)jarg1;
16373   arg2 = (Dali::BaseHandle *)jarg2;
16374   if (!arg2) {
16375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16376     return 0;
16377   }
16378   {
16379     try {
16380       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16381     } catch (std::out_of_range& e) {
16382       {
16383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16384       };
16385     } catch (std::exception& e) {
16386       {
16387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16388       };
16389     } catch (...) {
16390       {
16391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16392       };
16393     }
16394   }
16395   jresult = result;
16396   return jresult;
16397 }
16398
16399
16400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16401   void * jresult ;
16402   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16403   Dali::RefObject *result = 0 ;
16404
16405   arg1 = (Dali::BaseHandle *)jarg1;
16406   {
16407     try {
16408       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16409     } catch (std::out_of_range& e) {
16410       {
16411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (std::exception& e) {
16414       {
16415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16416       };
16417     } catch (...) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16420       };
16421     }
16422   }
16423   jresult = (void *)result;
16424   return jresult;
16425 }
16426
16427
16428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16429   unsigned int jresult ;
16430   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16431   bool result;
16432
16433   arg1 = (Dali::BaseHandle *)jarg1;
16434   {
16435     try {
16436       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16437     } catch (std::out_of_range& e) {
16438       {
16439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16440       };
16441     } catch (std::exception& e) {
16442       {
16443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (...) {
16446       {
16447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16448       };
16449     }
16450   }
16451   jresult = result;
16452   return jresult;
16453 }
16454
16455
16456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16457   unsigned int jresult ;
16458   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16459   Dali::BaseHandle *arg2 = 0 ;
16460   bool result;
16461
16462   arg1 = (Dali::BaseHandle *)jarg1;
16463   arg2 = (Dali::BaseHandle *)jarg2;
16464   if (!arg2) {
16465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16466     return 0;
16467   }
16468   {
16469     try {
16470       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16478       };
16479     } catch (...) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16482       };
16483     }
16484   }
16485   jresult = result;
16486   return jresult;
16487 }
16488
16489
16490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16491   unsigned int jresult ;
16492   Dali::BaseHandle *arg1 = 0 ;
16493   Dali::BaseHandle *arg2 = 0 ;
16494   bool result;
16495
16496   arg1 = (Dali::BaseHandle *)jarg1;
16497   if (!arg1) {
16498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16499     return 0;
16500   }
16501   arg2 = (Dali::BaseHandle *)jarg2;
16502   if (!arg2) {
16503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16504     return 0;
16505   }
16506   {
16507     try {
16508       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16509     } catch (std::out_of_range& e) {
16510       {
16511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16512       };
16513     } catch (std::exception& e) {
16514       {
16515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16520       };
16521     }
16522   }
16523   jresult = result;
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16529   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16530
16531   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16532   {
16533     try {
16534       delete arg1;
16535     } catch (std::out_of_range& e) {
16536       {
16537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16538       };
16539     } catch (std::exception& e) {
16540       {
16541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16542       };
16543     } catch (...) {
16544       {
16545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16546       };
16547     }
16548   }
16549 }
16550
16551
16552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16553   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16554   SlotObserver *arg2 = (SlotObserver *) 0 ;
16555   CallbackBase *arg3 = (CallbackBase *) 0 ;
16556
16557   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16558   arg2 = (SlotObserver *)jarg2;
16559   arg3 = (CallbackBase *)jarg3;
16560   {
16561     try {
16562       (arg1)->SignalConnected(arg2,arg3);
16563     } catch (std::out_of_range& e) {
16564       {
16565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16566       };
16567     } catch (std::exception& e) {
16568       {
16569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16570       };
16571     } catch (...) {
16572       {
16573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16574       };
16575     }
16576   }
16577 }
16578
16579
16580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16581   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16582
16583   arg1 = (Dali::SignalObserver *)jarg1;
16584   {
16585     try {
16586       delete arg1;
16587     } catch (std::out_of_range& e) {
16588       {
16589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16590       };
16591     } catch (std::exception& e) {
16592       {
16593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16594       };
16595     } catch (...) {
16596       {
16597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16598       };
16599     }
16600   }
16601 }
16602
16603
16604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16605   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16606   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16607   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16608
16609   arg1 = (Dali::SignalObserver *)jarg1;
16610   arg2 = (Dali::SlotObserver *)jarg2;
16611   arg3 = (Dali::CallbackBase *)jarg3;
16612   {
16613     try {
16614       (arg1)->SignalDisconnected(arg2,arg3);
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16622       };
16623     } catch (...) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16626       };
16627     }
16628   }
16629 }
16630
16631
16632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16633   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16634
16635   arg1 = (Dali::SlotObserver *)jarg1;
16636   {
16637     try {
16638       delete arg1;
16639     } catch (std::out_of_range& e) {
16640       {
16641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (std::exception& e) {
16644       {
16645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16646       };
16647     } catch (...) {
16648       {
16649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16650       };
16651     }
16652   }
16653 }
16654
16655
16656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16657   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16658   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16659
16660   arg1 = (Dali::SlotObserver *)jarg1;
16661   arg2 = (Dali::CallbackBase *)jarg2;
16662   {
16663     try {
16664       (arg1)->SlotDisconnected(arg2);
16665     } catch (std::out_of_range& e) {
16666       {
16667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16668       };
16669     } catch (std::exception& e) {
16670       {
16671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16672       };
16673     } catch (...) {
16674       {
16675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16676       };
16677     }
16678   }
16679 }
16680
16681
16682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16683   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16684
16685   arg1 = (Dali::ConnectionTracker *)jarg1;
16686   {
16687     try {
16688       delete arg1;
16689     } catch (std::out_of_range& e) {
16690       {
16691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16692       };
16693     } catch (std::exception& e) {
16694       {
16695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16700       };
16701     }
16702   }
16703 }
16704
16705
16706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16707   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16708
16709   arg1 = (Dali::ConnectionTracker *)jarg1;
16710   {
16711     try {
16712       (arg1)->DisconnectAll();
16713     } catch (std::out_of_range& e) {
16714       {
16715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16716       };
16717     } catch (std::exception& e) {
16718       {
16719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16720       };
16721     } catch (...) {
16722       {
16723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16724       };
16725     }
16726   }
16727 }
16728
16729
16730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16731   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16732   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16733   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16734
16735   arg1 = (Dali::ConnectionTracker *)jarg1;
16736   arg2 = (Dali::SlotObserver *)jarg2;
16737   arg3 = (Dali::CallbackBase *)jarg3;
16738   {
16739     try {
16740       (arg1)->SignalConnected(arg2,arg3);
16741     } catch (std::out_of_range& e) {
16742       {
16743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16744       };
16745     } catch (std::exception& e) {
16746       {
16747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16748       };
16749     } catch (...) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16752       };
16753     }
16754   }
16755 }
16756
16757
16758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16759   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16760   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16761   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16762
16763   arg1 = (Dali::ConnectionTracker *)jarg1;
16764   arg2 = (Dali::SlotObserver *)jarg2;
16765   arg3 = (Dali::CallbackBase *)jarg3;
16766   {
16767     try {
16768       (arg1)->SignalDisconnected(arg2,arg3);
16769     } catch (std::out_of_range& e) {
16770       {
16771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (std::exception& e) {
16774       {
16775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16776       };
16777     } catch (...) {
16778       {
16779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16780       };
16781     }
16782   }
16783 }
16784
16785
16786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16787   unsigned long jresult ;
16788   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16789   std::size_t result;
16790
16791   arg1 = (Dali::ConnectionTracker *)jarg1;
16792   {
16793     try {
16794       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16795     } catch (std::out_of_range& e) {
16796       {
16797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16798       };
16799     } catch (std::exception& e) {
16800       {
16801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16802       };
16803     } catch (...) {
16804       {
16805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16806       };
16807     }
16808   }
16809   jresult = (unsigned long)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16815   void * jresult ;
16816   Dali::ObjectRegistry *result = 0 ;
16817
16818   {
16819     try {
16820       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (...) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16832       };
16833     }
16834   }
16835   jresult = (void *)result;
16836   return jresult;
16837 }
16838
16839
16840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16841   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16842
16843   arg1 = (Dali::ObjectRegistry *)jarg1;
16844   {
16845     try {
16846       delete arg1;
16847     } catch (std::out_of_range& e) {
16848       {
16849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16850       };
16851     } catch (std::exception& e) {
16852       {
16853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16854       };
16855     } catch (...) {
16856       {
16857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16858       };
16859     }
16860   }
16861 }
16862
16863
16864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16865   void * jresult ;
16866   Dali::ObjectRegistry *arg1 = 0 ;
16867   Dali::ObjectRegistry *result = 0 ;
16868
16869   arg1 = (Dali::ObjectRegistry *)jarg1;
16870   if (!arg1) {
16871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16872     return 0;
16873   }
16874   {
16875     try {
16876       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16877     } catch (std::out_of_range& e) {
16878       {
16879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16880       };
16881     } catch (std::exception& e) {
16882       {
16883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16884       };
16885     } catch (...) {
16886       {
16887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16888       };
16889     }
16890   }
16891   jresult = (void *)result;
16892   return jresult;
16893 }
16894
16895
16896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16897   void * jresult ;
16898   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16899   Dali::ObjectRegistry *arg2 = 0 ;
16900   Dali::ObjectRegistry *result = 0 ;
16901
16902   arg1 = (Dali::ObjectRegistry *)jarg1;
16903   arg2 = (Dali::ObjectRegistry *)jarg2;
16904   if (!arg2) {
16905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16906     return 0;
16907   }
16908   {
16909     try {
16910       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16911     } catch (std::out_of_range& e) {
16912       {
16913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16914       };
16915     } catch (std::exception& e) {
16916       {
16917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16918       };
16919     } catch (...) {
16920       {
16921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16922       };
16923     }
16924   }
16925   jresult = (void *)result;
16926   return jresult;
16927 }
16928
16929
16930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16931   void * jresult ;
16932   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16933   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16934
16935   arg1 = (Dali::ObjectRegistry *)jarg1;
16936   {
16937     try {
16938       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16939     } catch (std::out_of_range& e) {
16940       {
16941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (std::exception& e) {
16944       {
16945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953   jresult = (void *)result;
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16959   void * jresult ;
16960   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16961   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16962
16963   arg1 = (Dali::ObjectRegistry *)jarg1;
16964   {
16965     try {
16966       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16967     } catch (std::out_of_range& e) {
16968       {
16969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16970       };
16971     } catch (std::exception& e) {
16972       {
16973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (...) {
16976       {
16977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16978       };
16979     }
16980   }
16981   jresult = (void *)result;
16982   return jresult;
16983 }
16984
16985
16986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16987   void * jresult ;
16988   Dali::PropertyCondition *result = 0 ;
16989
16990   {
16991     try {
16992       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16993     } catch (std::out_of_range& e) {
16994       {
16995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (std::exception& e) {
16998       {
16999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17000       };
17001     } catch (...) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17004       };
17005     }
17006   }
17007   jresult = (void *)result;
17008   return jresult;
17009 }
17010
17011
17012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17013   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17014
17015   arg1 = (Dali::PropertyCondition *)jarg1;
17016   {
17017     try {
17018       delete arg1;
17019     } catch (std::out_of_range& e) {
17020       {
17021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17022       };
17023     } catch (std::exception& e) {
17024       {
17025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17026       };
17027     } catch (...) {
17028       {
17029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17030       };
17031     }
17032   }
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17037   void * jresult ;
17038   Dali::PropertyCondition *arg1 = 0 ;
17039   Dali::PropertyCondition *result = 0 ;
17040
17041   arg1 = (Dali::PropertyCondition *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (...) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17060       };
17061     }
17062   }
17063   jresult = (void *)result;
17064   return jresult;
17065 }
17066
17067
17068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17069   void * jresult ;
17070   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17071   Dali::PropertyCondition *arg2 = 0 ;
17072   Dali::PropertyCondition *result = 0 ;
17073
17074   arg1 = (Dali::PropertyCondition *)jarg1;
17075   arg2 = (Dali::PropertyCondition *)jarg2;
17076   if (!arg2) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17078     return 0;
17079   }
17080   {
17081     try {
17082       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17083     } catch (std::out_of_range& e) {
17084       {
17085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (std::exception& e) {
17088       {
17089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (...) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17094       };
17095     }
17096   }
17097   jresult = (void *)result;
17098   return jresult;
17099 }
17100
17101
17102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17103   unsigned long jresult ;
17104   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17105   std::size_t result;
17106
17107   arg1 = (Dali::PropertyCondition *)jarg1;
17108   {
17109     try {
17110       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17111     } catch (std::out_of_range& e) {
17112       {
17113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17114       };
17115     } catch (std::exception& e) {
17116       {
17117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17118       };
17119     } catch (...) {
17120       {
17121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17122       };
17123     }
17124   }
17125   jresult = (unsigned long)result;
17126   return jresult;
17127 }
17128
17129
17130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17131   float jresult ;
17132   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17133   std::size_t arg2 ;
17134   float result;
17135
17136   arg1 = (Dali::PropertyCondition *)jarg1;
17137   arg2 = (std::size_t)jarg2;
17138   {
17139     try {
17140       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17141     } catch (std::out_of_range& e) {
17142       {
17143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17144       };
17145     } catch (std::exception& e) {
17146       {
17147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (...) {
17150       {
17151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17152       };
17153     }
17154   }
17155   jresult = result;
17156   return jresult;
17157 }
17158
17159
17160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17161   void * jresult ;
17162   float arg1 ;
17163   Dali::PropertyCondition result;
17164
17165   arg1 = (float)jarg1;
17166   {
17167     try {
17168       result = Dali::LessThanCondition(arg1);
17169     } catch (std::out_of_range& e) {
17170       {
17171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17172       };
17173     } catch (std::exception& e) {
17174       {
17175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17176       };
17177     } catch (...) {
17178       {
17179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17180       };
17181     }
17182   }
17183   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17189   void * jresult ;
17190   float arg1 ;
17191   Dali::PropertyCondition result;
17192
17193   arg1 = (float)jarg1;
17194   {
17195     try {
17196       result = Dali::GreaterThanCondition(arg1);
17197     } catch (std::out_of_range& e) {
17198       {
17199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (std::exception& e) {
17202       {
17203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (...) {
17206       {
17207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17208       };
17209     }
17210   }
17211   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17212   return jresult;
17213 }
17214
17215
17216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17217   void * jresult ;
17218   float arg1 ;
17219   float arg2 ;
17220   Dali::PropertyCondition result;
17221
17222   arg1 = (float)jarg1;
17223   arg2 = (float)jarg2;
17224   {
17225     try {
17226       result = Dali::InsideCondition(arg1,arg2);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (...) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17238       };
17239     }
17240   }
17241   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17242   return jresult;
17243 }
17244
17245
17246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17247   void * jresult ;
17248   float arg1 ;
17249   float arg2 ;
17250   Dali::PropertyCondition result;
17251
17252   arg1 = (float)jarg1;
17253   arg2 = (float)jarg2;
17254   {
17255     try {
17256       result = Dali::OutsideCondition(arg1,arg2);
17257     } catch (std::out_of_range& e) {
17258       {
17259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17260       };
17261     } catch (std::exception& e) {
17262       {
17263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17264       };
17265     } catch (...) {
17266       {
17267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17268       };
17269     }
17270   }
17271   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17272   return jresult;
17273 }
17274
17275
17276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17277   void * jresult ;
17278   float arg1 ;
17279   float arg2 ;
17280   Dali::PropertyCondition result;
17281
17282   arg1 = (float)jarg1;
17283   arg2 = (float)jarg2;
17284   {
17285     try {
17286       result = Dali::StepCondition(arg1,arg2);
17287     } catch (std::out_of_range& e) {
17288       {
17289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17290       };
17291     } catch (std::exception& e) {
17292       {
17293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17294       };
17295     } catch (...) {
17296       {
17297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17298       };
17299     }
17300   }
17301   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17302   return jresult;
17303 }
17304
17305
17306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17307   void * jresult ;
17308   float arg1 ;
17309   Dali::PropertyCondition result;
17310
17311   arg1 = (float)jarg1;
17312   {
17313     try {
17314       result = Dali::StepCondition(arg1);
17315     } catch (std::out_of_range& e) {
17316       {
17317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17318       };
17319     } catch (std::exception& e) {
17320       {
17321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17322       };
17323     } catch (...) {
17324       {
17325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17326       };
17327     }
17328   }
17329   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17330   return jresult;
17331 }
17332
17333
17334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17335   void * jresult ;
17336   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17337   Dali::PropertyCondition result;
17338
17339   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17340   if (!arg1) {
17341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17342     return 0;
17343   }
17344   {
17345     try {
17346       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17347     } catch (std::out_of_range& e) {
17348       {
17349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17350       };
17351     } catch (std::exception& e) {
17352       {
17353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17354       };
17355     } catch (...) {
17356       {
17357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17358       };
17359     }
17360   }
17361   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17362   return jresult;
17363 }
17364
17365
17366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17367   void * jresult ;
17368   Dali::PropertyNotification *result = 0 ;
17369
17370   {
17371     try {
17372       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17373     } catch (std::out_of_range& e) {
17374       {
17375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17376       };
17377     } catch (std::exception& e) {
17378       {
17379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17380       };
17381     } catch (...) {
17382       {
17383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17384       };
17385     }
17386   }
17387   jresult = (void *)result;
17388   return jresult;
17389 }
17390
17391
17392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17393   void * jresult ;
17394   Dali::BaseHandle arg1 ;
17395   Dali::BaseHandle *argp1 ;
17396   Dali::PropertyNotification result;
17397
17398   argp1 = (Dali::BaseHandle *)jarg1;
17399   if (!argp1) {
17400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17401     return 0;
17402   }
17403   arg1 = *argp1;
17404   {
17405     try {
17406       result = Dali::PropertyNotification::DownCast(arg1);
17407     } catch (std::out_of_range& e) {
17408       {
17409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17410       };
17411     } catch (std::exception& e) {
17412       {
17413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17414       };
17415     } catch (...) {
17416       {
17417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17418       };
17419     }
17420   }
17421   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17427   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17428
17429   arg1 = (Dali::PropertyNotification *)jarg1;
17430   {
17431     try {
17432       delete arg1;
17433     } catch (std::out_of_range& e) {
17434       {
17435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17436       };
17437     } catch (std::exception& e) {
17438       {
17439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17440       };
17441     } catch (...) {
17442       {
17443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17444       };
17445     }
17446   }
17447 }
17448
17449
17450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17451   void * jresult ;
17452   Dali::PropertyNotification *arg1 = 0 ;
17453   Dali::PropertyNotification *result = 0 ;
17454
17455   arg1 = (Dali::PropertyNotification *)jarg1;
17456   if (!arg1) {
17457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17458     return 0;
17459   }
17460   {
17461     try {
17462       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17463     } catch (std::out_of_range& e) {
17464       {
17465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17466       };
17467     } catch (std::exception& e) {
17468       {
17469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17470       };
17471     } catch (...) {
17472       {
17473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17474       };
17475     }
17476   }
17477   jresult = (void *)result;
17478   return jresult;
17479 }
17480
17481
17482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17483   void * jresult ;
17484   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17485   Dali::PropertyNotification *arg2 = 0 ;
17486   Dali::PropertyNotification *result = 0 ;
17487
17488   arg1 = (Dali::PropertyNotification *)jarg1;
17489   arg2 = (Dali::PropertyNotification *)jarg2;
17490   if (!arg2) {
17491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17492     return 0;
17493   }
17494   {
17495     try {
17496       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17497     } catch (std::out_of_range& e) {
17498       {
17499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17500       };
17501     } catch (std::exception& e) {
17502       {
17503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17504       };
17505     } catch (...) {
17506       {
17507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17508       };
17509     }
17510   }
17511   jresult = (void *)result;
17512   return jresult;
17513 }
17514
17515
17516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17517   void * jresult ;
17518   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17519   Dali::PropertyCondition result;
17520
17521   arg1 = (Dali::PropertyNotification *)jarg1;
17522   {
17523     try {
17524       result = (arg1)->GetCondition();
17525     } catch (std::out_of_range& e) {
17526       {
17527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17528       };
17529     } catch (std::exception& e) {
17530       {
17531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (...) {
17534       {
17535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17536       };
17537     }
17538   }
17539   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17540   return jresult;
17541 }
17542
17543
17544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17545   void * jresult ;
17546   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17547   Dali::Handle result;
17548
17549   arg1 = (Dali::PropertyNotification *)jarg1;
17550   {
17551     try {
17552       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17553     } catch (std::out_of_range& e) {
17554       {
17555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17556       };
17557     } catch (std::exception& e) {
17558       {
17559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17560       };
17561     } catch (...) {
17562       {
17563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17564       };
17565     }
17566   }
17567   jresult = new Dali::Handle((const Dali::Handle &)result);
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17573   int jresult ;
17574   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17575   Dali::Property::Index result;
17576
17577   arg1 = (Dali::PropertyNotification *)jarg1;
17578   {
17579     try {
17580       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17581     } catch (std::out_of_range& e) {
17582       {
17583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (std::exception& e) {
17586       {
17587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (...) {
17590       {
17591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17592       };
17593     }
17594   }
17595   jresult = result;
17596   return jresult;
17597 }
17598
17599
17600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17601   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17602   Dali::PropertyNotification::NotifyMode arg2 ;
17603
17604   arg1 = (Dali::PropertyNotification *)jarg1;
17605   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17606   {
17607     try {
17608       (arg1)->SetNotifyMode(arg2);
17609     } catch (std::out_of_range& e) {
17610       {
17611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17612       };
17613     } catch (std::exception& e) {
17614       {
17615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17616       };
17617     } catch (...) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17620       };
17621     }
17622   }
17623 }
17624
17625
17626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17627   int jresult ;
17628   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17629   Dali::PropertyNotification::NotifyMode result;
17630
17631   arg1 = (Dali::PropertyNotification *)jarg1;
17632   {
17633     try {
17634       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17635     } catch (std::out_of_range& e) {
17636       {
17637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17638       };
17639     } catch (std::exception& e) {
17640       {
17641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17642       };
17643     } catch (...) {
17644       {
17645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17646       };
17647     }
17648   }
17649   jresult = (int)result;
17650   return jresult;
17651 }
17652
17653
17654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17655   unsigned int jresult ;
17656   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17657   bool result;
17658
17659   arg1 = (Dali::PropertyNotification *)jarg1;
17660   {
17661     try {
17662       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17663     } catch (std::out_of_range& e) {
17664       {
17665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (std::exception& e) {
17668       {
17669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (...) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17674       };
17675     }
17676   }
17677   jresult = result;
17678   return jresult;
17679 }
17680
17681
17682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17683   void * jresult ;
17684   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17685   Dali::PropertyNotifySignalType *result = 0 ;
17686
17687   arg1 = (Dali::PropertyNotification *)jarg1;
17688   {
17689     try {
17690       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17691     } catch (std::out_of_range& e) {
17692       {
17693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17694       };
17695     } catch (std::exception& e) {
17696       {
17697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17698       };
17699     } catch (...) {
17700       {
17701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17702       };
17703     }
17704   }
17705   jresult = (void *)result;
17706   return jresult;
17707 }
17708
17709
17710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17711   void * jresult ;
17712   Dali::Handle *result = 0 ;
17713
17714   {
17715     try {
17716       result = (Dali::Handle *)new Dali::Handle();
17717     } catch (std::out_of_range& e) {
17718       {
17719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17720       };
17721     } catch (std::exception& e) {
17722       {
17723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17724       };
17725     } catch (...) {
17726       {
17727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17728       };
17729     }
17730   }
17731   jresult = (void *)result;
17732   return jresult;
17733 }
17734
17735
17736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17737   void * jresult ;
17738   Dali::Handle result;
17739
17740   {
17741     try {
17742       result = Dali::Handle::New();
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757   jresult = new Dali::Handle((const Dali::Handle &)result);
17758   return jresult;
17759 }
17760
17761
17762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17763   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17764
17765   arg1 = (Dali::Handle *)jarg1;
17766   {
17767     try {
17768       delete arg1;
17769     } catch (std::out_of_range& e) {
17770       {
17771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17772       };
17773     } catch (std::exception& e) {
17774       {
17775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17776       };
17777     } catch (...) {
17778       {
17779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17780       };
17781     }
17782   }
17783 }
17784
17785
17786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17787   void * jresult ;
17788   Dali::Handle *arg1 = 0 ;
17789   Dali::Handle *result = 0 ;
17790
17791   arg1 = (Dali::Handle *)jarg1;
17792   if (!arg1) {
17793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17794     return 0;
17795   }
17796   {
17797     try {
17798       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17799     } catch (std::out_of_range& e) {
17800       {
17801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17802       };
17803     } catch (std::exception& e) {
17804       {
17805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (...) {
17808       {
17809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17810       };
17811     }
17812   }
17813   jresult = (void *)result;
17814   return jresult;
17815 }
17816
17817
17818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17819   void * jresult ;
17820   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17821   Dali::Handle *arg2 = 0 ;
17822   Dali::Handle *result = 0 ;
17823
17824   arg1 = (Dali::Handle *)jarg1;
17825   arg2 = (Dali::Handle *)jarg2;
17826   if (!arg2) {
17827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17828     return 0;
17829   }
17830   {
17831     try {
17832       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17833     } catch (std::out_of_range& e) {
17834       {
17835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17836       };
17837     } catch (std::exception& e) {
17838       {
17839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17840       };
17841     } catch (...) {
17842       {
17843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17844       };
17845     }
17846   }
17847   jresult = (void *)result;
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17853   void * jresult ;
17854   Dali::BaseHandle arg1 ;
17855   Dali::BaseHandle *argp1 ;
17856   Dali::Handle result;
17857
17858   argp1 = (Dali::BaseHandle *)jarg1;
17859   if (!argp1) {
17860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17861     return 0;
17862   }
17863   arg1 = *argp1;
17864   {
17865     try {
17866       result = Dali::Handle::DownCast(arg1);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (...) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17878       };
17879     }
17880   }
17881   jresult = new Dali::Handle((const Dali::Handle &)result);
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17887   unsigned int jresult ;
17888   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17889   Dali::Handle::Capability arg2 ;
17890   bool result;
17891
17892   arg1 = (Dali::Handle *)jarg1;
17893   arg2 = (Dali::Handle::Capability)jarg2;
17894   {
17895     try {
17896       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17897     } catch (std::out_of_range& e) {
17898       {
17899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17900       };
17901     } catch (std::exception& e) {
17902       {
17903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (...) {
17906       {
17907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17908       };
17909     }
17910   }
17911   jresult = result;
17912   return jresult;
17913 }
17914
17915
17916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17917   unsigned int jresult ;
17918   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17919   unsigned int result;
17920
17921   arg1 = (Dali::Handle *)jarg1;
17922   {
17923     try {
17924       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17925     } catch (std::out_of_range& e) {
17926       {
17927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (std::exception& e) {
17930       {
17931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17932       };
17933     } catch (...) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17936       };
17937     }
17938   }
17939   jresult = result;
17940   return jresult;
17941 }
17942
17943
17944 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17945   char * jresult ;
17946   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17947   Dali::Property::Index arg2 ;
17948   std::string result;
17949
17950   arg1 = (Dali::Handle *)jarg1;
17951   arg2 = (Dali::Property::Index)jarg2;
17952   {
17953     try {
17954       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17955     } catch (std::out_of_range& e) {
17956       {
17957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17958       };
17959     } catch (std::exception& e) {
17960       {
17961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17962       };
17963     } catch (...) {
17964       {
17965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17966       };
17967     }
17968   }
17969   jresult = SWIG_csharp_string_callback((&result)->c_str());
17970   return jresult;
17971 }
17972
17973
17974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17975   int jresult ;
17976   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17977   std::string *arg2 = 0 ;
17978   Dali::Property::Index result;
17979
17980   arg1 = (Dali::Handle *)jarg1;
17981   if (!jarg2) {
17982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17983     return 0;
17984   }
17985   std::string arg2_str(jarg2);
17986   arg2 = &arg2_str;
17987   {
17988     try {
17989       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17990     } catch (std::out_of_range& e) {
17991       {
17992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17993       };
17994     } catch (std::exception& e) {
17995       {
17996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17997       };
17998     } catch (...) {
17999       {
18000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18001       };
18002     }
18003   }
18004   jresult = result;
18005
18006   //argout typemap for const std::string&
18007
18008   return jresult;
18009 }
18010
18011
18012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18013   unsigned int jresult ;
18014   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18015   Dali::Property::Index arg2 ;
18016   bool result;
18017
18018   arg1 = (Dali::Handle *)jarg1;
18019   arg2 = (Dali::Property::Index)jarg2;
18020   {
18021     try {
18022       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18023     } catch (std::out_of_range& e) {
18024       {
18025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18026       };
18027     } catch (std::exception& e) {
18028       {
18029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (...) {
18032       {
18033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18034       };
18035     }
18036   }
18037   jresult = result;
18038   return jresult;
18039 }
18040
18041
18042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18043   unsigned int jresult ;
18044   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18045   Dali::Property::Index arg2 ;
18046   bool result;
18047
18048   arg1 = (Dali::Handle *)jarg1;
18049   arg2 = (Dali::Property::Index)jarg2;
18050   {
18051     try {
18052       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18053     } catch (std::out_of_range& e) {
18054       {
18055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18056       };
18057     } catch (std::exception& e) {
18058       {
18059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (...) {
18062       {
18063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18064       };
18065     }
18066   }
18067   jresult = result;
18068   return jresult;
18069 }
18070
18071
18072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18073   unsigned int jresult ;
18074   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18075   Dali::Property::Index arg2 ;
18076   bool result;
18077
18078   arg1 = (Dali::Handle *)jarg1;
18079   arg2 = (Dali::Property::Index)jarg2;
18080   {
18081     try {
18082       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (...) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18094       };
18095     }
18096   }
18097   jresult = result;
18098   return jresult;
18099 }
18100
18101
18102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18103   int jresult ;
18104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18105   Dali::Property::Index arg2 ;
18106   Dali::Property::Type result;
18107
18108   arg1 = (Dali::Handle *)jarg1;
18109   arg2 = (Dali::Property::Index)jarg2;
18110   {
18111     try {
18112       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18113     } catch (std::out_of_range& e) {
18114       {
18115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18116       };
18117     } catch (std::exception& e) {
18118       {
18119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18120       };
18121     } catch (...) {
18122       {
18123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18124       };
18125     }
18126   }
18127   jresult = (int)result;
18128   return jresult;
18129 }
18130
18131
18132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18133   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18134   Dali::Property::Index arg2 ;
18135   Dali::Property::Value *arg3 = 0 ;
18136
18137   arg1 = (Dali::Handle *)jarg1;
18138   arg2 = (Dali::Property::Index)jarg2;
18139   arg3 = (Dali::Property::Value *)jarg3;
18140   if (!arg3) {
18141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18142     return ;
18143   }
18144   {
18145     try {
18146       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18147     } catch (std::out_of_range& e) {
18148       {
18149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18150       };
18151     } catch (std::exception& e) {
18152       {
18153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18154       };
18155     } catch (...) {
18156       {
18157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18158       };
18159     }
18160   }
18161 }
18162
18163
18164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18165   int jresult ;
18166   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18167   std::string *arg2 = 0 ;
18168   Dali::Property::Value *arg3 = 0 ;
18169   Dali::Property::Index result;
18170
18171   arg1 = (Dali::Handle *)jarg1;
18172   if (!jarg2) {
18173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18174     return 0;
18175   }
18176   std::string arg2_str(jarg2);
18177   arg2 = &arg2_str;
18178   arg3 = (Dali::Property::Value *)jarg3;
18179   if (!arg3) {
18180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18181     return 0;
18182   }
18183   {
18184     try {
18185       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18186     } catch (std::out_of_range& e) {
18187       {
18188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18189       };
18190     } catch (std::exception& e) {
18191       {
18192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (...) {
18195       {
18196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18197       };
18198     }
18199   }
18200   jresult = result;
18201
18202   //argout typemap for const std::string&
18203
18204   return jresult;
18205 }
18206
18207
18208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18209   int jresult ;
18210   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18211   std::string *arg2 = 0 ;
18212   Dali::Property::Value *arg3 = 0 ;
18213   Dali::Property::AccessMode arg4 ;
18214   Dali::Property::Index result;
18215
18216   arg1 = (Dali::Handle *)jarg1;
18217   if (!jarg2) {
18218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18219     return 0;
18220   }
18221   std::string arg2_str(jarg2);
18222   arg2 = &arg2_str;
18223   arg3 = (Dali::Property::Value *)jarg3;
18224   if (!arg3) {
18225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18226     return 0;
18227   }
18228   arg4 = (Dali::Property::AccessMode)jarg4;
18229   {
18230     try {
18231       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18232     } catch (std::out_of_range& e) {
18233       {
18234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18235       };
18236     } catch (std::exception& e) {
18237       {
18238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (...) {
18241       {
18242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18243       };
18244     }
18245   }
18246   jresult = result;
18247
18248   //argout typemap for const std::string&
18249
18250   return jresult;
18251 }
18252
18253
18254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18255   void * jresult ;
18256   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18257   Dali::Property::Index arg2 ;
18258   Dali::Property::Value result;
18259
18260   arg1 = (Dali::Handle *)jarg1;
18261   arg2 = (Dali::Property::Index)jarg2;
18262   {
18263     try {
18264       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18265     } catch (std::out_of_range& e) {
18266       {
18267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18268       };
18269     } catch (std::exception& e) {
18270       {
18271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18272       };
18273     } catch (...) {
18274       {
18275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18276       };
18277     }
18278   }
18279   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18280   return jresult;
18281 }
18282
18283
18284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18285   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18286   Dali::Property::IndexContainer *arg2 = 0 ;
18287
18288   arg1 = (Dali::Handle *)jarg1;
18289   arg2 = (Dali::Property::IndexContainer *)jarg2;
18290   if (!arg2) {
18291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18292     return ;
18293   }
18294   {
18295     try {
18296       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18297     } catch (std::out_of_range& e) {
18298       {
18299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18300       };
18301     } catch (std::exception& e) {
18302       {
18303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18304       };
18305     } catch (...) {
18306       {
18307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18308       };
18309     }
18310   }
18311 }
18312
18313
18314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18315   void * jresult ;
18316   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18317   Dali::Property::Index arg2 ;
18318   Dali::PropertyCondition *arg3 = 0 ;
18319   Dali::PropertyNotification result;
18320
18321   arg1 = (Dali::Handle *)jarg1;
18322   arg2 = (Dali::Property::Index)jarg2;
18323   arg3 = (Dali::PropertyCondition *)jarg3;
18324   if (!arg3) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18326     return 0;
18327   }
18328   {
18329     try {
18330       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (...) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18342       };
18343     }
18344   }
18345   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18346   return jresult;
18347 }
18348
18349
18350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18351   void * jresult ;
18352   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18353   Dali::Property::Index arg2 ;
18354   int arg3 ;
18355   Dali::PropertyCondition *arg4 = 0 ;
18356   Dali::PropertyNotification result;
18357
18358   arg1 = (Dali::Handle *)jarg1;
18359   arg2 = (Dali::Property::Index)jarg2;
18360   arg3 = (int)jarg3;
18361   arg4 = (Dali::PropertyCondition *)jarg4;
18362   if (!arg4) {
18363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18364     return 0;
18365   }
18366   {
18367     try {
18368       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18369     } catch (std::out_of_range& e) {
18370       {
18371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (std::exception& e) {
18374       {
18375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (...) {
18378       {
18379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18380       };
18381     }
18382   }
18383   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18384   return jresult;
18385 }
18386
18387
18388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18389   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18390   Dali::PropertyNotification arg2 ;
18391   Dali::PropertyNotification *argp2 ;
18392
18393   arg1 = (Dali::Handle *)jarg1;
18394   argp2 = (Dali::PropertyNotification *)jarg2;
18395   if (!argp2) {
18396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18397     return ;
18398   }
18399   arg2 = *argp2;
18400   {
18401     try {
18402       (arg1)->RemovePropertyNotification(arg2);
18403     } catch (std::out_of_range& e) {
18404       {
18405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18406       };
18407     } catch (std::exception& e) {
18408       {
18409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18410       };
18411     } catch (...) {
18412       {
18413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18414       };
18415     }
18416   }
18417 }
18418
18419
18420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18421   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18422
18423   arg1 = (Dali::Handle *)jarg1;
18424   {
18425     try {
18426       (arg1)->RemovePropertyNotifications();
18427     } catch (std::out_of_range& e) {
18428       {
18429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18430       };
18431     } catch (std::exception& e) {
18432       {
18433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18434       };
18435     } catch (...) {
18436       {
18437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18438       };
18439     }
18440   }
18441 }
18442
18443
18444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18445   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18446
18447   arg1 = (Dali::Handle *)jarg1;
18448   {
18449     try {
18450       (arg1)->RemoveConstraints();
18451     } catch (std::out_of_range& e) {
18452       {
18453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18454       };
18455     } catch (std::exception& e) {
18456       {
18457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18458       };
18459     } catch (...) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18462       };
18463     }
18464   }
18465 }
18466
18467
18468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18470   unsigned int arg2 ;
18471
18472   arg1 = (Dali::Handle *)jarg1;
18473   arg2 = (unsigned int)jarg2;
18474   {
18475     try {
18476       (arg1)->RemoveConstraints(arg2);
18477     } catch (std::out_of_range& e) {
18478       {
18479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18480       };
18481     } catch (std::exception& e) {
18482       {
18483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18484       };
18485     } catch (...) {
18486       {
18487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18488       };
18489     }
18490   }
18491 }
18492
18493
18494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18495   int jresult ;
18496   Dali::Property::Index result;
18497
18498   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18499   jresult = result;
18500   return jresult;
18501 }
18502
18503
18504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18505   void * jresult ;
18506   Dali::Handle result;
18507
18508   {
18509     try {
18510       result = Dali::WeightObject::New();
18511     } catch (std::out_of_range& e) {
18512       {
18513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18514       };
18515     } catch (std::exception& e) {
18516       {
18517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18518       };
18519     } catch (...) {
18520       {
18521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18522       };
18523     }
18524   }
18525   jresult = new Dali::Handle((const Dali::Handle &)result);
18526   return jresult;
18527 }
18528
18529
18530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18531   void * jresult ;
18532   Dali::TypeInfo *result = 0 ;
18533
18534   {
18535     try {
18536       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18537     } catch (std::out_of_range& e) {
18538       {
18539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18540       };
18541     } catch (std::exception& e) {
18542       {
18543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18544       };
18545     } catch (...) {
18546       {
18547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18548       };
18549     }
18550   }
18551   jresult = (void *)result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18557   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18558
18559   arg1 = (Dali::TypeInfo *)jarg1;
18560   {
18561     try {
18562       delete arg1;
18563     } catch (std::out_of_range& e) {
18564       {
18565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18566       };
18567     } catch (std::exception& e) {
18568       {
18569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18570       };
18571     } catch (...) {
18572       {
18573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18574       };
18575     }
18576   }
18577 }
18578
18579
18580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18581   void * jresult ;
18582   Dali::TypeInfo *arg1 = 0 ;
18583   Dali::TypeInfo *result = 0 ;
18584
18585   arg1 = (Dali::TypeInfo *)jarg1;
18586   if (!arg1) {
18587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18588     return 0;
18589   }
18590   {
18591     try {
18592       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18593     } catch (std::out_of_range& e) {
18594       {
18595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18596       };
18597     } catch (std::exception& e) {
18598       {
18599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18600       };
18601     } catch (...) {
18602       {
18603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18604       };
18605     }
18606   }
18607   jresult = (void *)result;
18608   return jresult;
18609 }
18610
18611
18612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18613   void * jresult ;
18614   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18615   Dali::TypeInfo *arg2 = 0 ;
18616   Dali::TypeInfo *result = 0 ;
18617
18618   arg1 = (Dali::TypeInfo *)jarg1;
18619   arg2 = (Dali::TypeInfo *)jarg2;
18620   if (!arg2) {
18621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18622     return 0;
18623   }
18624   {
18625     try {
18626       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18627     } catch (std::out_of_range& e) {
18628       {
18629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18630       };
18631     } catch (std::exception& e) {
18632       {
18633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18634       };
18635     } catch (...) {
18636       {
18637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18638       };
18639     }
18640   }
18641   jresult = (void *)result;
18642   return jresult;
18643 }
18644
18645
18646 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18647   char * jresult ;
18648   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18649   std::string *result = 0 ;
18650
18651   arg1 = (Dali::TypeInfo *)jarg1;
18652   {
18653     try {
18654       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18655     } catch (std::out_of_range& e) {
18656       {
18657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (std::exception& e) {
18660       {
18661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18662       };
18663     } catch (...) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18666       };
18667     }
18668   }
18669   jresult = SWIG_csharp_string_callback(result->c_str());
18670   return jresult;
18671 }
18672
18673
18674 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18675   char * jresult ;
18676   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18677   std::string *result = 0 ;
18678
18679   arg1 = (Dali::TypeInfo *)jarg1;
18680   {
18681     try {
18682       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18683     } catch (std::out_of_range& e) {
18684       {
18685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18686       };
18687     } catch (std::exception& e) {
18688       {
18689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18690       };
18691     } catch (...) {
18692       {
18693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18694       };
18695     }
18696   }
18697   jresult = SWIG_csharp_string_callback(result->c_str());
18698   return jresult;
18699 }
18700
18701
18702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18703   void * jresult ;
18704   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18705   Dali::BaseHandle result;
18706
18707   arg1 = (Dali::TypeInfo *)jarg1;
18708   {
18709     try {
18710       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18711     } catch (std::out_of_range& e) {
18712       {
18713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (std::exception& e) {
18716       {
18717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18726   return jresult;
18727 }
18728
18729
18730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18731   unsigned long jresult ;
18732   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18733   size_t result;
18734
18735   arg1 = (Dali::TypeInfo *)jarg1;
18736   {
18737     try {
18738       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18739     } catch (std::out_of_range& e) {
18740       {
18741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (std::exception& e) {
18744       {
18745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18746       };
18747     } catch (...) {
18748       {
18749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18750       };
18751     }
18752   }
18753   jresult = (unsigned long)result;
18754   return jresult;
18755 }
18756
18757
18758 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18759   char * jresult ;
18760   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18761   size_t arg2 ;
18762   std::string result;
18763
18764   arg1 = (Dali::TypeInfo *)jarg1;
18765   arg2 = (size_t)jarg2;
18766   {
18767     try {
18768       result = (arg1)->GetActionName(arg2);
18769     } catch (std::out_of_range& e) {
18770       {
18771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18772       };
18773     } catch (std::exception& e) {
18774       {
18775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (...) {
18778       {
18779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18780       };
18781     }
18782   }
18783   jresult = SWIG_csharp_string_callback((&result)->c_str());
18784   return jresult;
18785 }
18786
18787
18788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18789   unsigned long jresult ;
18790   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18791   size_t result;
18792
18793   arg1 = (Dali::TypeInfo *)jarg1;
18794   {
18795     try {
18796       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18797     } catch (std::out_of_range& e) {
18798       {
18799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18800       };
18801     } catch (std::exception& e) {
18802       {
18803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (...) {
18806       {
18807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18808       };
18809     }
18810   }
18811   jresult = (unsigned long)result;
18812   return jresult;
18813 }
18814
18815
18816 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18817   char * jresult ;
18818   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18819   size_t arg2 ;
18820   std::string result;
18821
18822   arg1 = (Dali::TypeInfo *)jarg1;
18823   arg2 = (size_t)jarg2;
18824   {
18825     try {
18826       result = (arg1)->GetSignalName(arg2);
18827     } catch (std::out_of_range& e) {
18828       {
18829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18830       };
18831     } catch (std::exception& e) {
18832       {
18833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18834       };
18835     } catch (...) {
18836       {
18837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18838       };
18839     }
18840   }
18841   jresult = SWIG_csharp_string_callback((&result)->c_str());
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18847   unsigned long jresult ;
18848   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18849   size_t result;
18850
18851   arg1 = (Dali::TypeInfo *)jarg1;
18852   {
18853     try {
18854       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18855     } catch (std::out_of_range& e) {
18856       {
18857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18858       };
18859     } catch (std::exception& e) {
18860       {
18861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18866       };
18867     }
18868   }
18869   jresult = (unsigned long)result;
18870   return jresult;
18871 }
18872
18873
18874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18875   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18876   Dali::Property::IndexContainer *arg2 = 0 ;
18877
18878   arg1 = (Dali::TypeInfo *)jarg1;
18879   arg2 = (Dali::Property::IndexContainer *)jarg2;
18880   if (!arg2) {
18881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18882     return ;
18883   }
18884   {
18885     try {
18886       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18887     } catch (std::out_of_range& e) {
18888       {
18889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (std::exception& e) {
18892       {
18893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901 }
18902
18903
18904 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18905   char * jresult ;
18906   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18907   Dali::Property::Index arg2 ;
18908   std::string *result = 0 ;
18909
18910   arg1 = (Dali::TypeInfo *)jarg1;
18911   arg2 = (Dali::Property::Index)jarg2;
18912   {
18913     try {
18914       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18922       };
18923     } catch (...) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18926       };
18927     }
18928   }
18929   jresult = SWIG_csharp_string_callback(result->c_str());
18930   return jresult;
18931 }
18932
18933
18934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18935   void * jresult ;
18936   Dali::TypeRegistry result;
18937
18938   {
18939     try {
18940       result = Dali::TypeRegistry::Get();
18941     } catch (std::out_of_range& e) {
18942       {
18943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18944       };
18945     } catch (std::exception& e) {
18946       {
18947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18948       };
18949     } catch (...) {
18950       {
18951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18952       };
18953     }
18954   }
18955   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18956   return jresult;
18957 }
18958
18959
18960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18961   void * jresult ;
18962   Dali::TypeRegistry *result = 0 ;
18963
18964   {
18965     try {
18966       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18967     } catch (std::out_of_range& e) {
18968       {
18969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18970       };
18971     } catch (std::exception& e) {
18972       {
18973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18974       };
18975     } catch (...) {
18976       {
18977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18978       };
18979     }
18980   }
18981   jresult = (void *)result;
18982   return jresult;
18983 }
18984
18985
18986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18987   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18988
18989   arg1 = (Dali::TypeRegistry *)jarg1;
18990   {
18991     try {
18992       delete arg1;
18993     } catch (std::out_of_range& e) {
18994       {
18995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18996       };
18997     } catch (std::exception& e) {
18998       {
18999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19000       };
19001     } catch (...) {
19002       {
19003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19004       };
19005     }
19006   }
19007 }
19008
19009
19010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19011   void * jresult ;
19012   Dali::TypeRegistry *arg1 = 0 ;
19013   Dali::TypeRegistry *result = 0 ;
19014
19015   arg1 = (Dali::TypeRegistry *)jarg1;
19016   if (!arg1) {
19017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19018     return 0;
19019   }
19020   {
19021     try {
19022       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19023     } catch (std::out_of_range& e) {
19024       {
19025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19026       };
19027     } catch (std::exception& e) {
19028       {
19029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19030       };
19031     } catch (...) {
19032       {
19033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19034       };
19035     }
19036   }
19037   jresult = (void *)result;
19038   return jresult;
19039 }
19040
19041
19042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19043   void * jresult ;
19044   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19045   Dali::TypeRegistry *arg2 = 0 ;
19046   Dali::TypeRegistry *result = 0 ;
19047
19048   arg1 = (Dali::TypeRegistry *)jarg1;
19049   arg2 = (Dali::TypeRegistry *)jarg2;
19050   if (!arg2) {
19051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19052     return 0;
19053   }
19054   {
19055     try {
19056       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19057     } catch (std::out_of_range& e) {
19058       {
19059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19060       };
19061     } catch (std::exception& e) {
19062       {
19063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19064       };
19065     } catch (...) {
19066       {
19067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19068       };
19069     }
19070   }
19071   jresult = (void *)result;
19072   return jresult;
19073 }
19074
19075
19076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19077   void * jresult ;
19078   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19079   std::string *arg2 = 0 ;
19080   Dali::TypeInfo result;
19081
19082   arg1 = (Dali::TypeRegistry *)jarg1;
19083   if (!jarg2) {
19084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19085     return 0;
19086   }
19087   std::string arg2_str(jarg2);
19088   arg2 = &arg2_str;
19089   {
19090     try {
19091       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19092     } catch (std::out_of_range& e) {
19093       {
19094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19095       };
19096     } catch (std::exception& e) {
19097       {
19098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19103       };
19104     }
19105   }
19106   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19107
19108   //argout typemap for const std::string&
19109
19110   return jresult;
19111 }
19112
19113
19114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19115   void * jresult ;
19116   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19117   std::type_info *arg2 = 0 ;
19118   Dali::TypeInfo result;
19119
19120   arg1 = (Dali::TypeRegistry *)jarg1;
19121   arg2 = (std::type_info *)jarg2;
19122   if (!arg2) {
19123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19124     return 0;
19125   }
19126   {
19127     try {
19128       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19136       };
19137     } catch (...) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19140       };
19141     }
19142   }
19143   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19144   return jresult;
19145 }
19146
19147
19148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19149   unsigned long jresult ;
19150   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19151   size_t result;
19152
19153   arg1 = (Dali::TypeRegistry *)jarg1;
19154   {
19155     try {
19156       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19168       };
19169     }
19170   }
19171   jresult = (unsigned long)result;
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19177   char * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   size_t arg2 ;
19180   std::string result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   arg2 = (size_t)jarg2;
19184   {
19185     try {
19186       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19187     } catch (std::out_of_range& e) {
19188       {
19189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19190       };
19191     } catch (std::exception& e) {
19192       {
19193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19198       };
19199     }
19200   }
19201   jresult = SWIG_csharp_string_callback((&result)->c_str());
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19207   void * jresult ;
19208   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19209   Dali::TypeRegistry *result = 0 ;
19210
19211   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19212   {
19213     try {
19214       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19215     } catch (std::out_of_range& e) {
19216       {
19217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19218       };
19219     } catch (std::exception& e) {
19220       {
19221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19222       };
19223     } catch (...) {
19224       {
19225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19226       };
19227     }
19228   }
19229   jresult = (void *)result;
19230   return jresult;
19231 }
19232
19233
19234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19235   void * jresult ;
19236   std::type_info *arg1 = 0 ;
19237   std::type_info *arg2 = 0 ;
19238   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19239   Dali::TypeRegistration *result = 0 ;
19240
19241   arg1 = (std::type_info *)jarg1;
19242   if (!arg1) {
19243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19244     return 0;
19245   }
19246   arg2 = (std::type_info *)jarg2;
19247   if (!arg2) {
19248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19249     return 0;
19250   }
19251   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19252   {
19253     try {
19254       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (...) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19266       };
19267     }
19268   }
19269   jresult = (void *)result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19275   void * jresult ;
19276   std::type_info *arg1 = 0 ;
19277   std::type_info *arg2 = 0 ;
19278   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19279   bool arg4 ;
19280   Dali::TypeRegistration *result = 0 ;
19281
19282   arg1 = (std::type_info *)jarg1;
19283   if (!arg1) {
19284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19285     return 0;
19286   }
19287   arg2 = (std::type_info *)jarg2;
19288   if (!arg2) {
19289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19290     return 0;
19291   }
19292   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19293   arg4 = jarg4 ? true : false;
19294   {
19295     try {
19296       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (...) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19308       };
19309     }
19310   }
19311   jresult = (void *)result;
19312   return jresult;
19313 }
19314
19315
19316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19317   void * jresult ;
19318   std::string *arg1 = 0 ;
19319   std::type_info *arg2 = 0 ;
19320   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19321   Dali::TypeRegistration *result = 0 ;
19322
19323   if (!jarg1) {
19324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19325     return 0;
19326   }
19327   std::string arg1_str(jarg1);
19328   arg1 = &arg1_str;
19329   arg2 = (std::type_info *)jarg2;
19330   if (!arg2) {
19331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19332     return 0;
19333   }
19334   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19335   {
19336     try {
19337       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19338     } catch (std::out_of_range& e) {
19339       {
19340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19341       };
19342     } catch (std::exception& e) {
19343       {
19344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19345       };
19346     } catch (...) {
19347       {
19348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19349       };
19350     }
19351   }
19352   jresult = (void *)result;
19353
19354   //argout typemap for const std::string&
19355
19356   return jresult;
19357 }
19358
19359
19360 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19361   char * jresult ;
19362   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19363   std::string result;
19364
19365   arg1 = (Dali::TypeRegistration *)jarg1;
19366   {
19367     try {
19368       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19369     } catch (std::out_of_range& e) {
19370       {
19371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (std::exception& e) {
19374       {
19375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383   jresult = SWIG_csharp_string_callback((&result)->c_str());
19384   return jresult;
19385 }
19386
19387
19388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19389   std::string *arg1 = 0 ;
19390   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19391
19392   if (!jarg1) {
19393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19394     return ;
19395   }
19396   std::string arg1_str(jarg1);
19397   arg1 = &arg1_str;
19398   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19399   {
19400     try {
19401       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19402     } catch (std::out_of_range& e) {
19403       {
19404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19405       };
19406     } catch (std::exception& e) {
19407       {
19408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19409       };
19410     } catch (...) {
19411       {
19412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19413       };
19414     }
19415   }
19416
19417   //argout typemap for const std::string&
19418
19419 }
19420
19421
19422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19423   std::string *arg1 = 0 ;
19424   std::string *arg2 = 0 ;
19425   int arg3 ;
19426   Dali::Property::Type arg4 ;
19427   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19428   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19429
19430   if (!jarg1) {
19431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19432     return ;
19433   }
19434   std::string arg1_str(jarg1);
19435   arg1 = &arg1_str;
19436   if (!jarg2) {
19437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19438     return ;
19439   }
19440   std::string arg2_str(jarg2);
19441   arg2 = &arg2_str;
19442   arg3 = (int)jarg3;
19443   arg4 = (Dali::Property::Type)jarg4;
19444   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19445   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19446   {
19447     try {
19448       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19449     } catch (std::out_of_range& e) {
19450       {
19451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19452       };
19453     } catch (std::exception& e) {
19454       {
19455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19460       };
19461     }
19462   }
19463
19464   //argout typemap for const std::string&
19465
19466
19467   //argout typemap for const std::string&
19468
19469 }
19470
19471
19472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19473   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19474
19475   arg1 = (Dali::TypeRegistration *)jarg1;
19476   {
19477     try {
19478       delete arg1;
19479     } catch (std::out_of_range& e) {
19480       {
19481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19482       };
19483     } catch (std::exception& e) {
19484       {
19485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19486       };
19487     } catch (...) {
19488       {
19489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19490       };
19491     }
19492   }
19493 }
19494
19495
19496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19497   void * jresult ;
19498   Dali::TypeRegistration *arg1 = 0 ;
19499   std::string *arg2 = 0 ;
19500   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19501   Dali::SignalConnectorType *result = 0 ;
19502
19503   arg1 = (Dali::TypeRegistration *)jarg1;
19504   if (!arg1) {
19505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19506     return 0;
19507   }
19508   if (!jarg2) {
19509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19510     return 0;
19511   }
19512   std::string arg2_str(jarg2);
19513   arg2 = &arg2_str;
19514   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19515   {
19516     try {
19517       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19518     } catch (std::out_of_range& e) {
19519       {
19520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19521       };
19522     } catch (std::exception& e) {
19523       {
19524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19525       };
19526     } catch (...) {
19527       {
19528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19529       };
19530     }
19531   }
19532   jresult = (void *)result;
19533
19534   //argout typemap for const std::string&
19535
19536   return jresult;
19537 }
19538
19539
19540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19541   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19542
19543   arg1 = (Dali::SignalConnectorType *)jarg1;
19544   {
19545     try {
19546       delete arg1;
19547     } catch (std::out_of_range& e) {
19548       {
19549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19550       };
19551     } catch (std::exception& e) {
19552       {
19553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19554       };
19555     } catch (...) {
19556       {
19557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19558       };
19559     }
19560   }
19561 }
19562
19563
19564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19565   void * jresult ;
19566   Dali::TypeRegistration *arg1 = 0 ;
19567   std::string *arg2 = 0 ;
19568   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19569   Dali::TypeAction *result = 0 ;
19570
19571   arg1 = (Dali::TypeRegistration *)jarg1;
19572   if (!arg1) {
19573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19574     return 0;
19575   }
19576   if (!jarg2) {
19577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19578     return 0;
19579   }
19580   std::string arg2_str(jarg2);
19581   arg2 = &arg2_str;
19582   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19583   {
19584     try {
19585       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19586     } catch (std::out_of_range& e) {
19587       {
19588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (std::exception& e) {
19591       {
19592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (...) {
19595       {
19596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19597       };
19598     }
19599   }
19600   jresult = (void *)result;
19601
19602   //argout typemap for const std::string&
19603
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19609   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19610
19611   arg1 = (Dali::TypeAction *)jarg1;
19612   {
19613     try {
19614       delete arg1;
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19626       };
19627     }
19628   }
19629 }
19630
19631
19632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19633   void * jresult ;
19634   Dali::TypeRegistration *arg1 = 0 ;
19635   std::string *arg2 = 0 ;
19636   Dali::Property::Index arg3 ;
19637   Dali::Property::Type arg4 ;
19638   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19639   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19640   Dali::PropertyRegistration *result = 0 ;
19641
19642   arg1 = (Dali::TypeRegistration *)jarg1;
19643   if (!arg1) {
19644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19645     return 0;
19646   }
19647   if (!jarg2) {
19648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19649     return 0;
19650   }
19651   std::string arg2_str(jarg2);
19652   arg2 = &arg2_str;
19653   arg3 = (Dali::Property::Index)jarg3;
19654   arg4 = (Dali::Property::Type)jarg4;
19655   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19656   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19657   {
19658     try {
19659       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (...) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19671       };
19672     }
19673   }
19674   jresult = (void *)result;
19675
19676   //argout typemap for const std::string&
19677
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19683   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19684
19685   arg1 = (Dali::PropertyRegistration *)jarg1;
19686   {
19687     try {
19688       delete arg1;
19689     } catch (std::out_of_range& e) {
19690       {
19691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19692       };
19693     } catch (std::exception& e) {
19694       {
19695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19696       };
19697     } catch (...) {
19698       {
19699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19700       };
19701     }
19702   }
19703 }
19704
19705
19706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19707   void * jresult ;
19708   Dali::TypeRegistration *arg1 = 0 ;
19709   std::string *arg2 = 0 ;
19710   Dali::Property::Index arg3 ;
19711   Dali::Property::Type arg4 ;
19712   Dali::AnimatablePropertyRegistration *result = 0 ;
19713
19714   arg1 = (Dali::TypeRegistration *)jarg1;
19715   if (!arg1) {
19716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19717     return 0;
19718   }
19719   if (!jarg2) {
19720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19721     return 0;
19722   }
19723   std::string arg2_str(jarg2);
19724   arg2 = &arg2_str;
19725   arg3 = (Dali::Property::Index)jarg3;
19726   arg4 = (Dali::Property::Type)jarg4;
19727   {
19728     try {
19729       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (...) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19741       };
19742     }
19743   }
19744   jresult = (void *)result;
19745
19746   //argout typemap for const std::string&
19747
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19753   void * jresult ;
19754   Dali::TypeRegistration *arg1 = 0 ;
19755   std::string *arg2 = 0 ;
19756   Dali::Property::Index arg3 ;
19757   Dali::Property::Value *arg4 = 0 ;
19758   Dali::AnimatablePropertyRegistration *result = 0 ;
19759
19760   arg1 = (Dali::TypeRegistration *)jarg1;
19761   if (!arg1) {
19762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19763     return 0;
19764   }
19765   if (!jarg2) {
19766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19767     return 0;
19768   }
19769   std::string arg2_str(jarg2);
19770   arg2 = &arg2_str;
19771   arg3 = (Dali::Property::Index)jarg3;
19772   arg4 = (Dali::Property::Value *)jarg4;
19773   if (!arg4) {
19774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19775     return 0;
19776   }
19777   {
19778     try {
19779       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19780     } catch (std::out_of_range& e) {
19781       {
19782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19783       };
19784     } catch (std::exception& e) {
19785       {
19786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19787       };
19788     } catch (...) {
19789       {
19790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19791       };
19792     }
19793   }
19794   jresult = (void *)result;
19795
19796   //argout typemap for const std::string&
19797
19798   return jresult;
19799 }
19800
19801
19802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19803   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19804
19805   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19806   {
19807     try {
19808       delete arg1;
19809     } catch (std::out_of_range& e) {
19810       {
19811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19812       };
19813     } catch (std::exception& e) {
19814       {
19815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19816       };
19817     } catch (...) {
19818       {
19819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19820       };
19821     }
19822   }
19823 }
19824
19825
19826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19827   void * jresult ;
19828   Dali::TypeRegistration *arg1 = 0 ;
19829   std::string *arg2 = 0 ;
19830   Dali::Property::Index arg3 ;
19831   Dali::Property::Index arg4 ;
19832   unsigned int arg5 ;
19833   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19834
19835   arg1 = (Dali::TypeRegistration *)jarg1;
19836   if (!arg1) {
19837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19838     return 0;
19839   }
19840   if (!jarg2) {
19841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19842     return 0;
19843   }
19844   std::string arg2_str(jarg2);
19845   arg2 = &arg2_str;
19846   arg3 = (Dali::Property::Index)jarg3;
19847   arg4 = (Dali::Property::Index)jarg4;
19848   arg5 = (unsigned int)jarg5;
19849   {
19850     try {
19851       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19852     } catch (std::out_of_range& e) {
19853       {
19854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19855       };
19856     } catch (std::exception& e) {
19857       {
19858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19859       };
19860     } catch (...) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19863       };
19864     }
19865   }
19866   jresult = (void *)result;
19867
19868   //argout typemap for const std::string&
19869
19870   return jresult;
19871 }
19872
19873
19874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19875   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19876
19877   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19878   {
19879     try {
19880       delete arg1;
19881     } catch (std::out_of_range& e) {
19882       {
19883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19884       };
19885     } catch (std::exception& e) {
19886       {
19887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19888       };
19889     } catch (...) {
19890       {
19891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19892       };
19893     }
19894   }
19895 }
19896
19897
19898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19899   void * jresult ;
19900   Dali::TypeRegistration *arg1 = 0 ;
19901   std::string *arg2 = 0 ;
19902   Dali::Property::Index arg3 ;
19903   Dali::Property::Type arg4 ;
19904   Dali::ChildPropertyRegistration *result = 0 ;
19905
19906   arg1 = (Dali::TypeRegistration *)jarg1;
19907   if (!arg1) {
19908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19909     return 0;
19910   }
19911   if (!jarg2) {
19912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19913     return 0;
19914   }
19915   std::string arg2_str(jarg2);
19916   arg2 = &arg2_str;
19917   arg3 = (Dali::Property::Index)jarg3;
19918   arg4 = (Dali::Property::Type)jarg4;
19919   {
19920     try {
19921       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19922     } catch (std::out_of_range& e) {
19923       {
19924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19925       };
19926     } catch (std::exception& e) {
19927       {
19928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19929       };
19930     } catch (...) {
19931       {
19932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19933       };
19934     }
19935   }
19936   jresult = (void *)result;
19937
19938   //argout typemap for const std::string&
19939
19940   return jresult;
19941 }
19942
19943
19944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19945   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19946
19947   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19948   {
19949     try {
19950       delete arg1;
19951     } catch (std::out_of_range& e) {
19952       {
19953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19954       };
19955     } catch (std::exception& e) {
19956       {
19957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19958       };
19959     } catch (...) {
19960       {
19961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19962       };
19963     }
19964   }
19965 }
19966
19967
19968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19969   unsigned int jresult ;
19970   std::string *arg1 = 0 ;
19971   std::type_info *arg2 = 0 ;
19972   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19973   bool result;
19974
19975   if (!jarg1) {
19976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19977     return 0;
19978   }
19979   std::string arg1_str(jarg1);
19980   arg1 = &arg1_str;
19981   arg2 = (std::type_info *)jarg2;
19982   if (!arg2) {
19983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19984     return 0;
19985   }
19986   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19987   {
19988     try {
19989       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19990     } catch (std::out_of_range& e) {
19991       {
19992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19993       };
19994     } catch (std::exception& e) {
19995       {
19996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19997       };
19998     } catch (...) {
19999       {
20000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20001       };
20002     }
20003   }
20004   jresult = result;
20005
20006   //argout typemap for const std::string&
20007
20008   return jresult;
20009 }
20010
20011
20012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20013   unsigned int jresult ;
20014   std::string *arg1 = 0 ;
20015   std::string *arg2 = 0 ;
20016   Dali::Property::Index arg3 ;
20017   Dali::Property::Type arg4 ;
20018   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20019   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20020   bool result;
20021
20022   if (!jarg1) {
20023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20024     return 0;
20025   }
20026   std::string arg1_str(jarg1);
20027   arg1 = &arg1_str;
20028   if (!jarg2) {
20029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20030     return 0;
20031   }
20032   std::string arg2_str(jarg2);
20033   arg2 = &arg2_str;
20034   arg3 = (Dali::Property::Index)jarg3;
20035   arg4 = (Dali::Property::Type)jarg4;
20036   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20037   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20038   {
20039     try {
20040       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (...) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20052       };
20053     }
20054   }
20055   jresult = result;
20056
20057   //argout typemap for const std::string&
20058
20059
20060   //argout typemap for const std::string&
20061
20062   return jresult;
20063 }
20064
20065
20066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20067   float jresult ;
20068   float result;
20069
20070   result = (float)(float)Dali::ParentOrigin::TOP;
20071   jresult = result;
20072   return jresult;
20073 }
20074
20075
20076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20077   float jresult ;
20078   float result;
20079
20080   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20081   jresult = result;
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20087   float jresult ;
20088   float result;
20089
20090   result = (float)(float)Dali::ParentOrigin::LEFT;
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20097   float jresult ;
20098   float result;
20099
20100   result = (float)(float)Dali::ParentOrigin::RIGHT;
20101   jresult = result;
20102   return jresult;
20103 }
20104
20105
20106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20107   float jresult ;
20108   float result;
20109
20110   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20111   jresult = result;
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20117   void * jresult ;
20118   Dali::Vector3 *result = 0 ;
20119
20120   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20121   jresult = (void *)result;
20122   return jresult;
20123 }
20124
20125
20126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20127   void * jresult ;
20128   Dali::Vector3 *result = 0 ;
20129
20130   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20131   jresult = (void *)result;
20132   return jresult;
20133 }
20134
20135
20136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20137   void * jresult ;
20138   Dali::Vector3 *result = 0 ;
20139
20140   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20141   jresult = (void *)result;
20142   return jresult;
20143 }
20144
20145
20146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20147   void * jresult ;
20148   Dali::Vector3 *result = 0 ;
20149
20150   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20151   jresult = (void *)result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20157   void * jresult ;
20158   Dali::Vector3 *result = 0 ;
20159
20160   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20161   jresult = (void *)result;
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20167   void * jresult ;
20168   Dali::Vector3 *result = 0 ;
20169
20170   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20171   jresult = (void *)result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20177   void * jresult ;
20178   Dali::Vector3 *result = 0 ;
20179
20180   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20181   jresult = (void *)result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20187   void * jresult ;
20188   Dali::Vector3 *result = 0 ;
20189
20190   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20191   jresult = (void *)result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20197   void * jresult ;
20198   Dali::Vector3 *result = 0 ;
20199
20200   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20201   jresult = (void *)result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20207   float jresult ;
20208   float result;
20209
20210   result = (float)(float)Dali::AnchorPoint::TOP;
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20217   float jresult ;
20218   float result;
20219
20220   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20221   jresult = result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20227   float jresult ;
20228   float result;
20229
20230   result = (float)(float)Dali::AnchorPoint::LEFT;
20231   jresult = result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20237   float jresult ;
20238   float result;
20239
20240   result = (float)(float)Dali::AnchorPoint::RIGHT;
20241   jresult = result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20247   float jresult ;
20248   float result;
20249
20250   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20251   jresult = result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20287   void * jresult ;
20288   Dali::Vector3 *result = 0 ;
20289
20290   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20291   jresult = (void *)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20297   void * jresult ;
20298   Dali::Vector3 *result = 0 ;
20299
20300   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20301   jresult = (void *)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20307   void * jresult ;
20308   Dali::Vector3 *result = 0 ;
20309
20310   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20311   jresult = (void *)result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20317   void * jresult ;
20318   Dali::Vector3 *result = 0 ;
20319
20320   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20321   jresult = (void *)result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20327   void * jresult ;
20328   Dali::Vector3 *result = 0 ;
20329
20330   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20331   jresult = (void *)result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20337   void * jresult ;
20338   Dali::Vector3 *result = 0 ;
20339
20340   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20341   jresult = (void *)result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20347   void * jresult ;
20348   Dali::Vector4 *result = 0 ;
20349
20350   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20357   void * jresult ;
20358   Dali::Vector4 *result = 0 ;
20359
20360   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20367   void * jresult ;
20368   Dali::Vector4 *result = 0 ;
20369
20370   result = (Dali::Vector4 *)&Dali::Color::RED;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20377   void * jresult ;
20378   Dali::Vector4 *result = 0 ;
20379
20380   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20387   void * jresult ;
20388   Dali::Vector4 *result = 0 ;
20389
20390   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20397   void * jresult ;
20398   Dali::Vector4 *result = 0 ;
20399
20400   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20407   void * jresult ;
20408   Dali::Vector4 *result = 0 ;
20409
20410   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20417   void * jresult ;
20418   Dali::Vector4 *result = 0 ;
20419
20420   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20427   void * jresult ;
20428   Dali::Vector4 *result = 0 ;
20429
20430   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20437   float jresult ;
20438   float result;
20439
20440   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20441   jresult = result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20447   float jresult ;
20448   float result;
20449
20450   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20451   jresult = result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20457   float jresult ;
20458   float result;
20459
20460   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20467   float jresult ;
20468   float result;
20469
20470   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20471   jresult = result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20477   float jresult ;
20478   float result;
20479
20480   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20481   jresult = result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20487   float jresult ;
20488   float result;
20489
20490   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20491   jresult = result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20497   float jresult ;
20498   float result;
20499
20500   result = (float)(float)Dali::Math::PI;
20501   jresult = result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20507   float jresult ;
20508   float result;
20509
20510   result = (float)(float)Dali::Math::PI_2;
20511   jresult = result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20517   float jresult ;
20518   float result;
20519
20520   result = (float)(float)Dali::Math::PI_4;
20521   jresult = result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20527   float jresult ;
20528   float result;
20529
20530   result = (float)(float)Dali::Math::PI_OVER_180;
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20547   int jresult ;
20548   Dali::ResizePolicy::Type result;
20549
20550   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20551   jresult = (int)result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20557   unsigned long jresult ;
20558   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20559   Dali::VectorBase::SizeType result;
20560
20561   arg1 = (Dali::VectorBase *)jarg1;
20562   {
20563     try {
20564       result = ((Dali::VectorBase const *)arg1)->Count();
20565     } catch (std::out_of_range& e) {
20566       {
20567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20568       };
20569     } catch (std::exception& e) {
20570       {
20571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20572       };
20573     } catch (...) {
20574       {
20575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20576       };
20577     }
20578   }
20579   jresult = (unsigned long)result;
20580   return jresult;
20581 }
20582
20583
20584 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20585   unsigned long jresult ;
20586   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20587   Dali::VectorBase::SizeType result;
20588
20589   arg1 = (Dali::VectorBase *)jarg1;
20590   {
20591     try {
20592       result = ((Dali::VectorBase const *)arg1)->Size();
20593     } catch (std::out_of_range& e) {
20594       {
20595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (std::exception& e) {
20598       {
20599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607   jresult = (unsigned long)result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20613   unsigned int jresult ;
20614   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20615   bool result;
20616
20617   arg1 = (Dali::VectorBase *)jarg1;
20618   {
20619     try {
20620       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20621     } catch (std::out_of_range& e) {
20622       {
20623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20624       };
20625     } catch (std::exception& e) {
20626       {
20627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (...) {
20630       {
20631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20632       };
20633     }
20634   }
20635   jresult = result;
20636   return jresult;
20637 }
20638
20639
20640 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20641   unsigned long jresult ;
20642   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20643   Dali::VectorBase::SizeType result;
20644
20645   arg1 = (Dali::VectorBase *)jarg1;
20646   {
20647     try {
20648       result = ((Dali::VectorBase const *)arg1)->Capacity();
20649     } catch (std::out_of_range& e) {
20650       {
20651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (std::exception& e) {
20654       {
20655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20656       };
20657     } catch (...) {
20658       {
20659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20660       };
20661     }
20662   }
20663   jresult = (unsigned long)result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20669   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20670
20671   arg1 = (Dali::VectorBase *)jarg1;
20672   {
20673     try {
20674       (arg1)->Release();
20675     } catch (std::out_of_range& e) {
20676       {
20677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20678       };
20679     } catch (std::exception& e) {
20680       {
20681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20682       };
20683     } catch (...) {
20684       {
20685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20686       };
20687     }
20688   }
20689 }
20690
20691
20692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20693   void * jresult ;
20694   Dali::Image *result = 0 ;
20695
20696   {
20697     try {
20698       result = (Dali::Image *)new Dali::Image();
20699     } catch (std::out_of_range& e) {
20700       {
20701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (std::exception& e) {
20704       {
20705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713   jresult = (void *)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20719   Dali::Image *arg1 = (Dali::Image *) 0 ;
20720
20721   arg1 = (Dali::Image *)jarg1;
20722   {
20723     try {
20724       delete arg1;
20725     } catch (std::out_of_range& e) {
20726       {
20727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20728       };
20729     } catch (std::exception& e) {
20730       {
20731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20732       };
20733     } catch (...) {
20734       {
20735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20736       };
20737     }
20738   }
20739 }
20740
20741
20742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20743   void * jresult ;
20744   Dali::Image *arg1 = 0 ;
20745   Dali::Image *result = 0 ;
20746
20747   arg1 = (Dali::Image *)jarg1;
20748   if (!arg1) {
20749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20750     return 0;
20751   }
20752   {
20753     try {
20754       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20762       };
20763     } catch (...) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20766       };
20767     }
20768   }
20769   jresult = (void *)result;
20770   return jresult;
20771 }
20772
20773
20774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20775   void * jresult ;
20776   Dali::Image *arg1 = (Dali::Image *) 0 ;
20777   Dali::Image *arg2 = 0 ;
20778   Dali::Image *result = 0 ;
20779
20780   arg1 = (Dali::Image *)jarg1;
20781   arg2 = (Dali::Image *)jarg2;
20782   if (!arg2) {
20783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20784     return 0;
20785   }
20786   {
20787     try {
20788       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20789     } catch (std::out_of_range& e) {
20790       {
20791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20792       };
20793     } catch (std::exception& e) {
20794       {
20795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20796       };
20797     } catch (...) {
20798       {
20799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20800       };
20801     }
20802   }
20803   jresult = (void *)result;
20804   return jresult;
20805 }
20806
20807
20808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20809   void * jresult ;
20810   Dali::BaseHandle arg1 ;
20811   Dali::BaseHandle *argp1 ;
20812   Dali::Image result;
20813
20814   argp1 = (Dali::BaseHandle *)jarg1;
20815   if (!argp1) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20817     return 0;
20818   }
20819   arg1 = *argp1;
20820   {
20821     try {
20822       result = Dali::Image::DownCast(arg1);
20823     } catch (std::out_of_range& e) {
20824       {
20825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20826       };
20827     } catch (std::exception& e) {
20828       {
20829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (...) {
20832       {
20833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20834       };
20835     }
20836   }
20837   jresult = new Dali::Image((const Dali::Image &)result);
20838   return jresult;
20839 }
20840
20841
20842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20843   unsigned int jresult ;
20844   Dali::Image *arg1 = (Dali::Image *) 0 ;
20845   unsigned int result;
20846
20847   arg1 = (Dali::Image *)jarg1;
20848   {
20849     try {
20850       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20851     } catch (std::out_of_range& e) {
20852       {
20853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (std::exception& e) {
20856       {
20857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (...) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20862       };
20863     }
20864   }
20865   jresult = result;
20866   return jresult;
20867 }
20868
20869
20870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20871   unsigned int jresult ;
20872   Dali::Image *arg1 = (Dali::Image *) 0 ;
20873   unsigned int result;
20874
20875   arg1 = (Dali::Image *)jarg1;
20876   {
20877     try {
20878       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20879     } catch (std::out_of_range& e) {
20880       {
20881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20882       };
20883     } catch (std::exception& e) {
20884       {
20885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20886       };
20887     } catch (...) {
20888       {
20889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20890       };
20891     }
20892   }
20893   jresult = result;
20894   return jresult;
20895 }
20896
20897
20898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20899   void * jresult ;
20900   Dali::Image *arg1 = (Dali::Image *) 0 ;
20901   Dali::Image::ImageSignalType *result = 0 ;
20902
20903   arg1 = (Dali::Image *)jarg1;
20904   {
20905     try {
20906       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20907     } catch (std::out_of_range& e) {
20908       {
20909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20910       };
20911     } catch (std::exception& e) {
20912       {
20913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20918       };
20919     }
20920   }
20921   jresult = (void *)result;
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20927   int jresult ;
20928   Dali::Pixel::Format result;
20929
20930   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20931   jresult = (int)result;
20932   return jresult;
20933 }
20934
20935
20936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20937   int jresult ;
20938   Dali::Pixel::Format result;
20939
20940   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20941   jresult = (int)result;
20942   return jresult;
20943 }
20944
20945
20946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20947   unsigned int jresult ;
20948   Dali::Pixel::Format arg1 ;
20949   bool result;
20950
20951   arg1 = (Dali::Pixel::Format)jarg1;
20952   {
20953     try {
20954       result = (bool)Dali::Pixel::HasAlpha(arg1);
20955     } catch (std::out_of_range& e) {
20956       {
20957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (std::exception& e) {
20960       {
20961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20962       };
20963     } catch (...) {
20964       {
20965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20966       };
20967     }
20968   }
20969   jresult = result;
20970   return jresult;
20971 }
20972
20973
20974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20975   unsigned int jresult ;
20976   Dali::Pixel::Format arg1 ;
20977   unsigned int result;
20978
20979   arg1 = (Dali::Pixel::Format)jarg1;
20980   {
20981     try {
20982       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20983     } catch (std::out_of_range& e) {
20984       {
20985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (std::exception& e) {
20988       {
20989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (...) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20994       };
20995     }
20996   }
20997   jresult = result;
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21003   Dali::Pixel::Format arg1 ;
21004   int *arg2 = 0 ;
21005   int *arg3 = 0 ;
21006
21007   arg1 = (Dali::Pixel::Format)jarg1;
21008   arg2 = (int *)jarg2;
21009   if (!arg2) {
21010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21011     return ;
21012   }
21013   arg3 = (int *)jarg3;
21014   if (!arg3) {
21015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21016     return ;
21017   }
21018   {
21019     try {
21020       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21028       };
21029     } catch (...) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21032       };
21033     }
21034   }
21035 }
21036
21037
21038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21039   void * jresult ;
21040   unsigned char *arg1 = (unsigned char *) 0 ;
21041   unsigned int arg2 ;
21042   unsigned int arg3 ;
21043   unsigned int arg4 ;
21044   Dali::Pixel::Format arg5 ;
21045   Dali::PixelData::ReleaseFunction arg6 ;
21046   Dali::PixelData result;
21047
21048   arg1 = jarg1;
21049   arg2 = (unsigned int)jarg2;
21050   arg3 = (unsigned int)jarg3;
21051   arg4 = (unsigned int)jarg4;
21052   arg5 = (Dali::Pixel::Format)jarg5;
21053   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21054   {
21055     try {
21056       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21057     } catch (std::out_of_range& e) {
21058       {
21059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21060       };
21061     } catch (std::exception& e) {
21062       {
21063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21068       };
21069     }
21070   }
21071   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21072
21073
21074   return jresult;
21075 }
21076
21077
21078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21079   void * jresult ;
21080   Dali::PixelData *result = 0 ;
21081
21082   {
21083     try {
21084       result = (Dali::PixelData *)new Dali::PixelData();
21085     } catch (std::out_of_range& e) {
21086       {
21087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21088       };
21089     } catch (std::exception& e) {
21090       {
21091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21096       };
21097     }
21098   }
21099   jresult = (void *)result;
21100   return jresult;
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21106
21107   arg1 = (Dali::PixelData *)jarg1;
21108   {
21109     try {
21110       delete arg1;
21111     } catch (std::out_of_range& e) {
21112       {
21113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21114       };
21115     } catch (std::exception& e) {
21116       {
21117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (...) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21122       };
21123     }
21124   }
21125 }
21126
21127
21128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21129   void * jresult ;
21130   Dali::PixelData *arg1 = 0 ;
21131   Dali::PixelData *result = 0 ;
21132
21133   arg1 = (Dali::PixelData *)jarg1;
21134   if (!arg1) {
21135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21136     return 0;
21137   }
21138   {
21139     try {
21140       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21141     } catch (std::out_of_range& e) {
21142       {
21143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21144       };
21145     } catch (std::exception& e) {
21146       {
21147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21148       };
21149     } catch (...) {
21150       {
21151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21152       };
21153     }
21154   }
21155   jresult = (void *)result;
21156   return jresult;
21157 }
21158
21159
21160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21161   void * jresult ;
21162   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21163   Dali::PixelData *arg2 = 0 ;
21164   Dali::PixelData *result = 0 ;
21165
21166   arg1 = (Dali::PixelData *)jarg1;
21167   arg2 = (Dali::PixelData *)jarg2;
21168   if (!arg2) {
21169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21170     return 0;
21171   }
21172   {
21173     try {
21174       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21175     } catch (std::out_of_range& e) {
21176       {
21177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21178       };
21179     } catch (std::exception& e) {
21180       {
21181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21182       };
21183     } catch (...) {
21184       {
21185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21186       };
21187     }
21188   }
21189   jresult = (void *)result;
21190   return jresult;
21191 }
21192
21193
21194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21195   unsigned int jresult ;
21196   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21197   unsigned int result;
21198
21199   arg1 = (Dali::PixelData *)jarg1;
21200   {
21201     try {
21202       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21203     } catch (std::out_of_range& e) {
21204       {
21205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21206       };
21207     } catch (std::exception& e) {
21208       {
21209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21210       };
21211     } catch (...) {
21212       {
21213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21214       };
21215     }
21216   }
21217   jresult = result;
21218   return jresult;
21219 }
21220
21221
21222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21223   unsigned int jresult ;
21224   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21225   unsigned int result;
21226
21227   arg1 = (Dali::PixelData *)jarg1;
21228   {
21229     try {
21230       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21231     } catch (std::out_of_range& e) {
21232       {
21233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21234       };
21235     } catch (std::exception& e) {
21236       {
21237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21238       };
21239     } catch (...) {
21240       {
21241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21242       };
21243     }
21244   }
21245   jresult = result;
21246   return jresult;
21247 }
21248
21249
21250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21251   int jresult ;
21252   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21253   Dali::Pixel::Format result;
21254
21255   arg1 = (Dali::PixelData *)jarg1;
21256   {
21257     try {
21258       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21259     } catch (std::out_of_range& e) {
21260       {
21261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21262       };
21263     } catch (std::exception& e) {
21264       {
21265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21266       };
21267     } catch (...) {
21268       {
21269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21270       };
21271     }
21272   }
21273   jresult = (int)result;
21274   return jresult;
21275 }
21276
21277
21278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21279   unsigned int jresult ;
21280   unsigned int result;
21281
21282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21283   jresult = result;
21284   return jresult;
21285 }
21286
21287
21288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21289   unsigned int jresult ;
21290   unsigned int result;
21291
21292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21293   jresult = result;
21294   return jresult;
21295 }
21296
21297
21298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21299   unsigned int jresult ;
21300   unsigned int result;
21301
21302   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21303   jresult = result;
21304   return jresult;
21305 }
21306
21307
21308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21309   unsigned int jresult ;
21310   unsigned int result;
21311
21312   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21313   jresult = result;
21314   return jresult;
21315 }
21316
21317
21318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21319   unsigned int jresult ;
21320   unsigned int result;
21321
21322   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21323   jresult = result;
21324   return jresult;
21325 }
21326
21327
21328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21329   unsigned int jresult ;
21330   unsigned int result;
21331
21332   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21333   jresult = result;
21334   return jresult;
21335 }
21336
21337
21338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21339   void * jresult ;
21340   Dali::TextureType::Type arg1 ;
21341   Dali::Pixel::Format arg2 ;
21342   unsigned int arg3 ;
21343   unsigned int arg4 ;
21344   Dali::Texture result;
21345
21346   arg1 = (Dali::TextureType::Type)jarg1;
21347   arg2 = (Dali::Pixel::Format)jarg2;
21348   arg3 = (unsigned int)jarg3;
21349   arg4 = (unsigned int)jarg4;
21350   {
21351     try {
21352       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (...) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21364       };
21365     }
21366   }
21367   jresult = new Dali::Texture((const Dali::Texture &)result);
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21373   void * jresult ;
21374   NativeImageInterface *arg1 = 0 ;
21375   Dali::Texture result;
21376
21377   arg1 = (NativeImageInterface *)jarg1;
21378   if (!arg1) {
21379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21380     return 0;
21381   }
21382   {
21383     try {
21384       result = Dali::Texture::New(*arg1);
21385     } catch (std::out_of_range& e) {
21386       {
21387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (std::exception& e) {
21390       {
21391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (...) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21396       };
21397     }
21398   }
21399   jresult = new Dali::Texture((const Dali::Texture &)result);
21400   return jresult;
21401 }
21402
21403
21404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21405   void * jresult ;
21406   Dali::Texture *result = 0 ;
21407
21408   {
21409     try {
21410       result = (Dali::Texture *)new Dali::Texture();
21411     } catch (std::out_of_range& e) {
21412       {
21413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21414       };
21415     } catch (std::exception& e) {
21416       {
21417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21418       };
21419     } catch (...) {
21420       {
21421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21422       };
21423     }
21424   }
21425   jresult = (void *)result;
21426   return jresult;
21427 }
21428
21429
21430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21431   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21432
21433   arg1 = (Dali::Texture *)jarg1;
21434   {
21435     try {
21436       delete arg1;
21437     } catch (std::out_of_range& e) {
21438       {
21439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21440       };
21441     } catch (std::exception& e) {
21442       {
21443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21444       };
21445     } catch (...) {
21446       {
21447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21448       };
21449     }
21450   }
21451 }
21452
21453
21454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21455   void * jresult ;
21456   Dali::Texture *arg1 = 0 ;
21457   Dali::Texture *result = 0 ;
21458
21459   arg1 = (Dali::Texture *)jarg1;
21460   if (!arg1) {
21461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21462     return 0;
21463   }
21464   {
21465     try {
21466       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21467     } catch (std::out_of_range& e) {
21468       {
21469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21470       };
21471     } catch (std::exception& e) {
21472       {
21473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21474       };
21475     } catch (...) {
21476       {
21477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21478       };
21479     }
21480   }
21481   jresult = (void *)result;
21482   return jresult;
21483 }
21484
21485
21486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21487   void * jresult ;
21488   Dali::BaseHandle arg1 ;
21489   Dali::BaseHandle *argp1 ;
21490   Dali::Texture result;
21491
21492   argp1 = (Dali::BaseHandle *)jarg1;
21493   if (!argp1) {
21494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21495     return 0;
21496   }
21497   arg1 = *argp1;
21498   {
21499     try {
21500       result = Dali::Texture::DownCast(arg1);
21501     } catch (std::out_of_range& e) {
21502       {
21503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21504       };
21505     } catch (std::exception& e) {
21506       {
21507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21508       };
21509     } catch (...) {
21510       {
21511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21512       };
21513     }
21514   }
21515   jresult = new Dali::Texture((const Dali::Texture &)result);
21516   return jresult;
21517 }
21518
21519
21520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21521   void * jresult ;
21522   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21523   Dali::Texture *arg2 = 0 ;
21524   Dali::Texture *result = 0 ;
21525
21526   arg1 = (Dali::Texture *)jarg1;
21527   arg2 = (Dali::Texture *)jarg2;
21528   if (!arg2) {
21529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21530     return 0;
21531   }
21532   {
21533     try {
21534       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21535     } catch (std::out_of_range& e) {
21536       {
21537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21538       };
21539     } catch (std::exception& e) {
21540       {
21541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21542       };
21543     } catch (...) {
21544       {
21545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21546       };
21547     }
21548   }
21549   jresult = (void *)result;
21550   return jresult;
21551 }
21552
21553
21554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21555   unsigned int jresult ;
21556   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21557   Dali::PixelData arg2 ;
21558   Dali::PixelData *argp2 ;
21559   bool result;
21560
21561   arg1 = (Dali::Texture *)jarg1;
21562   argp2 = (Dali::PixelData *)jarg2;
21563   if (!argp2) {
21564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21565     return 0;
21566   }
21567   arg2 = *argp2;
21568   {
21569     try {
21570       result = (bool)(arg1)->Upload(arg2);
21571     } catch (std::out_of_range& e) {
21572       {
21573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (std::exception& e) {
21576       {
21577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21578       };
21579     } catch (...) {
21580       {
21581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21582       };
21583     }
21584   }
21585   jresult = result;
21586   return jresult;
21587 }
21588
21589
21590 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) {
21591   unsigned int jresult ;
21592   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21593   Dali::PixelData arg2 ;
21594   unsigned int arg3 ;
21595   unsigned int arg4 ;
21596   unsigned int arg5 ;
21597   unsigned int arg6 ;
21598   unsigned int arg7 ;
21599   unsigned int arg8 ;
21600   Dali::PixelData *argp2 ;
21601   bool result;
21602
21603   arg1 = (Dali::Texture *)jarg1;
21604   argp2 = (Dali::PixelData *)jarg2;
21605   if (!argp2) {
21606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21607     return 0;
21608   }
21609   arg2 = *argp2;
21610   arg3 = (unsigned int)jarg3;
21611   arg4 = (unsigned int)jarg4;
21612   arg5 = (unsigned int)jarg5;
21613   arg6 = (unsigned int)jarg6;
21614   arg7 = (unsigned int)jarg7;
21615   arg8 = (unsigned int)jarg8;
21616   {
21617     try {
21618       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21619     } catch (std::out_of_range& e) {
21620       {
21621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21622       };
21623     } catch (std::exception& e) {
21624       {
21625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21626       };
21627     } catch (...) {
21628       {
21629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21630       };
21631     }
21632   }
21633   jresult = result;
21634   return jresult;
21635 }
21636
21637
21638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21639   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21640
21641   arg1 = (Dali::Texture *)jarg1;
21642   {
21643     try {
21644       (arg1)->GenerateMipmaps();
21645     } catch (std::out_of_range& e) {
21646       {
21647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21648       };
21649     } catch (std::exception& e) {
21650       {
21651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21652       };
21653     } catch (...) {
21654       {
21655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21656       };
21657     }
21658   }
21659 }
21660
21661
21662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21663   unsigned int jresult ;
21664   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21665   unsigned int result;
21666
21667   arg1 = (Dali::Texture *)jarg1;
21668   {
21669     try {
21670       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21682       };
21683     }
21684   }
21685   jresult = result;
21686   return jresult;
21687 }
21688
21689
21690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21691   unsigned int jresult ;
21692   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21693   unsigned int result;
21694
21695   arg1 = (Dali::Texture *)jarg1;
21696   {
21697     try {
21698       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21699     } catch (std::out_of_range& e) {
21700       {
21701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (std::exception& e) {
21704       {
21705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713   jresult = result;
21714   return jresult;
21715 }
21716
21717
21718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21719   void * jresult ;
21720   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21721   Dali::Texture *result = 0 ;
21722
21723   arg1 = (Dali::Internal::Texture *)jarg1;
21724   {
21725     try {
21726       result = (Dali::Texture *)new Dali::Texture(arg1);
21727     } catch (std::out_of_range& e) {
21728       {
21729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21730       };
21731     } catch (std::exception& e) {
21732       {
21733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21734       };
21735     } catch (...) {
21736       {
21737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21738       };
21739     }
21740   }
21741   jresult = (void *)result;
21742   return jresult;
21743 }
21744
21745
21746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21747   void * jresult ;
21748   Dali::Sampler result;
21749
21750   {
21751     try {
21752       result = Dali::Sampler::New();
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (...) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21764       };
21765     }
21766   }
21767   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21768   return jresult;
21769 }
21770
21771
21772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21773   void * jresult ;
21774   Dali::Sampler *result = 0 ;
21775
21776   {
21777     try {
21778       result = (Dali::Sampler *)new Dali::Sampler();
21779     } catch (std::out_of_range& e) {
21780       {
21781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (std::exception& e) {
21784       {
21785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21790       };
21791     }
21792   }
21793   jresult = (void *)result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21799   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21800
21801   arg1 = (Dali::Sampler *)jarg1;
21802   {
21803     try {
21804       delete arg1;
21805     } catch (std::out_of_range& e) {
21806       {
21807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21808       };
21809     } catch (std::exception& e) {
21810       {
21811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21812       };
21813     } catch (...) {
21814       {
21815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21816       };
21817     }
21818   }
21819 }
21820
21821
21822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21823   void * jresult ;
21824   Dali::Sampler *arg1 = 0 ;
21825   Dali::Sampler *result = 0 ;
21826
21827   arg1 = (Dali::Sampler *)jarg1;
21828   if (!arg1) {
21829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21830     return 0;
21831   }
21832   {
21833     try {
21834       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (...) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21846       };
21847     }
21848   }
21849   jresult = (void *)result;
21850   return jresult;
21851 }
21852
21853
21854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21855   void * jresult ;
21856   Dali::BaseHandle arg1 ;
21857   Dali::BaseHandle *argp1 ;
21858   Dali::Sampler result;
21859
21860   argp1 = (Dali::BaseHandle *)jarg1;
21861   if (!argp1) {
21862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21863     return 0;
21864   }
21865   arg1 = *argp1;
21866   {
21867     try {
21868       result = Dali::Sampler::DownCast(arg1);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (...) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21880       };
21881     }
21882   }
21883   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21884   return jresult;
21885 }
21886
21887
21888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21889   void * jresult ;
21890   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21891   Dali::Sampler *arg2 = 0 ;
21892   Dali::Sampler *result = 0 ;
21893
21894   arg1 = (Dali::Sampler *)jarg1;
21895   arg2 = (Dali::Sampler *)jarg2;
21896   if (!arg2) {
21897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21898     return 0;
21899   }
21900   {
21901     try {
21902       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21903     } catch (std::out_of_range& e) {
21904       {
21905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21906       };
21907     } catch (std::exception& e) {
21908       {
21909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (...) {
21912       {
21913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21914       };
21915     }
21916   }
21917   jresult = (void *)result;
21918   return jresult;
21919 }
21920
21921
21922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21923   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21924   Dali::FilterMode::Type arg2 ;
21925   Dali::FilterMode::Type arg3 ;
21926
21927   arg1 = (Dali::Sampler *)jarg1;
21928   arg2 = (Dali::FilterMode::Type)jarg2;
21929   arg3 = (Dali::FilterMode::Type)jarg3;
21930   {
21931     try {
21932       (arg1)->SetFilterMode(arg2,arg3);
21933     } catch (std::out_of_range& e) {
21934       {
21935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21936       };
21937     } catch (std::exception& e) {
21938       {
21939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21940       };
21941     } catch (...) {
21942       {
21943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21944       };
21945     }
21946   }
21947 }
21948
21949
21950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21951   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21952   Dali::WrapMode::Type arg2 ;
21953   Dali::WrapMode::Type arg3 ;
21954
21955   arg1 = (Dali::Sampler *)jarg1;
21956   arg2 = (Dali::WrapMode::Type)jarg2;
21957   arg3 = (Dali::WrapMode::Type)jarg3;
21958   {
21959     try {
21960       (arg1)->SetWrapMode(arg2,arg3);
21961     } catch (std::out_of_range& e) {
21962       {
21963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21964       };
21965     } catch (std::exception& e) {
21966       {
21967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21968       };
21969     } catch (...) {
21970       {
21971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21972       };
21973     }
21974   }
21975 }
21976
21977
21978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21979   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21980   Dali::WrapMode::Type arg2 ;
21981   Dali::WrapMode::Type arg3 ;
21982   Dali::WrapMode::Type arg4 ;
21983
21984   arg1 = (Dali::Sampler *)jarg1;
21985   arg2 = (Dali::WrapMode::Type)jarg2;
21986   arg3 = (Dali::WrapMode::Type)jarg3;
21987   arg4 = (Dali::WrapMode::Type)jarg4;
21988   {
21989     try {
21990       (arg1)->SetWrapMode(arg2,arg3,arg4);
21991     } catch (std::out_of_range& e) {
21992       {
21993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21994       };
21995     } catch (std::exception& e) {
21996       {
21997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22002       };
22003     }
22004   }
22005 }
22006
22007
22008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22009   void * jresult ;
22010   Dali::TextureSet result;
22011
22012   {
22013     try {
22014       result = Dali::TextureSet::New();
22015     } catch (std::out_of_range& e) {
22016       {
22017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22018       };
22019     } catch (std::exception& e) {
22020       {
22021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (...) {
22024       {
22025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22026       };
22027     }
22028   }
22029   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22035   void * jresult ;
22036   Dali::TextureSet *result = 0 ;
22037
22038   {
22039     try {
22040       result = (Dali::TextureSet *)new Dali::TextureSet();
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055   jresult = (void *)result;
22056   return jresult;
22057 }
22058
22059
22060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22061   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22062
22063   arg1 = (Dali::TextureSet *)jarg1;
22064   {
22065     try {
22066       delete arg1;
22067     } catch (std::out_of_range& e) {
22068       {
22069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22070       };
22071     } catch (std::exception& e) {
22072       {
22073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22074       };
22075     } catch (...) {
22076       {
22077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22078       };
22079     }
22080   }
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22085   void * jresult ;
22086   Dali::TextureSet *arg1 = 0 ;
22087   Dali::TextureSet *result = 0 ;
22088
22089   arg1 = (Dali::TextureSet *)jarg1;
22090   if (!arg1) {
22091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22092     return 0;
22093   }
22094   {
22095     try {
22096       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22097     } catch (std::out_of_range& e) {
22098       {
22099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22100       };
22101     } catch (std::exception& e) {
22102       {
22103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22104       };
22105     } catch (...) {
22106       {
22107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22108       };
22109     }
22110   }
22111   jresult = (void *)result;
22112   return jresult;
22113 }
22114
22115
22116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22117   void * jresult ;
22118   Dali::BaseHandle arg1 ;
22119   Dali::BaseHandle *argp1 ;
22120   Dali::TextureSet result;
22121
22122   argp1 = (Dali::BaseHandle *)jarg1;
22123   if (!argp1) {
22124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22125     return 0;
22126   }
22127   arg1 = *argp1;
22128   {
22129     try {
22130       result = Dali::TextureSet::DownCast(arg1);
22131     } catch (std::out_of_range& e) {
22132       {
22133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22134       };
22135     } catch (std::exception& e) {
22136       {
22137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22138       };
22139     } catch (...) {
22140       {
22141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22142       };
22143     }
22144   }
22145   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22146   return jresult;
22147 }
22148
22149
22150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22151   void * jresult ;
22152   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22153   Dali::TextureSet *arg2 = 0 ;
22154   Dali::TextureSet *result = 0 ;
22155
22156   arg1 = (Dali::TextureSet *)jarg1;
22157   arg2 = (Dali::TextureSet *)jarg2;
22158   if (!arg2) {
22159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22160     return 0;
22161   }
22162   {
22163     try {
22164       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22165     } catch (std::out_of_range& e) {
22166       {
22167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22168       };
22169     } catch (std::exception& e) {
22170       {
22171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22172       };
22173     } catch (...) {
22174       {
22175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22176       };
22177     }
22178   }
22179   jresult = (void *)result;
22180   return jresult;
22181 }
22182
22183
22184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22185   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22186   size_t arg2 ;
22187   Dali::Texture arg3 ;
22188   Dali::Texture *argp3 ;
22189
22190   arg1 = (Dali::TextureSet *)jarg1;
22191   arg2 = (size_t)jarg2;
22192   argp3 = (Dali::Texture *)jarg3;
22193   if (!argp3) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22195     return ;
22196   }
22197   arg3 = *argp3;
22198   {
22199     try {
22200       (arg1)->SetTexture(arg2,arg3);
22201     } catch (std::out_of_range& e) {
22202       {
22203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22204       };
22205     } catch (std::exception& e) {
22206       {
22207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22208       };
22209     } catch (...) {
22210       {
22211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22212       };
22213     }
22214   }
22215 }
22216
22217
22218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22219   void * jresult ;
22220   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22221   size_t arg2 ;
22222   Dali::Texture result;
22223
22224   arg1 = (Dali::TextureSet *)jarg1;
22225   arg2 = (size_t)jarg2;
22226   {
22227     try {
22228       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22236       };
22237     } catch (...) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22240       };
22241     }
22242   }
22243   jresult = new Dali::Texture((const Dali::Texture &)result);
22244   return jresult;
22245 }
22246
22247
22248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22249   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22250   size_t arg2 ;
22251   Dali::Sampler arg3 ;
22252   Dali::Sampler *argp3 ;
22253
22254   arg1 = (Dali::TextureSet *)jarg1;
22255   arg2 = (size_t)jarg2;
22256   argp3 = (Dali::Sampler *)jarg3;
22257   if (!argp3) {
22258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22259     return ;
22260   }
22261   arg3 = *argp3;
22262   {
22263     try {
22264       (arg1)->SetSampler(arg2,arg3);
22265     } catch (std::out_of_range& e) {
22266       {
22267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22268       };
22269     } catch (std::exception& e) {
22270       {
22271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22276       };
22277     }
22278   }
22279 }
22280
22281
22282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22283   void * jresult ;
22284   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22285   size_t arg2 ;
22286   Dali::Sampler result;
22287
22288   arg1 = (Dali::TextureSet *)jarg1;
22289   arg2 = (size_t)jarg2;
22290   {
22291     try {
22292       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22293     } catch (std::out_of_range& e) {
22294       {
22295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22296       };
22297     } catch (std::exception& e) {
22298       {
22299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22300       };
22301     } catch (...) {
22302       {
22303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22304       };
22305     }
22306   }
22307   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22313   unsigned long jresult ;
22314   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22315   size_t result;
22316
22317   arg1 = (Dali::TextureSet *)jarg1;
22318   {
22319     try {
22320       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22321     } catch (std::out_of_range& e) {
22322       {
22323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22324       };
22325     } catch (std::exception& e) {
22326       {
22327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22328       };
22329     } catch (...) {
22330       {
22331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22332       };
22333     }
22334   }
22335   jresult = (unsigned long)result;
22336   return jresult;
22337 }
22338
22339
22340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22341   void * jresult ;
22342   Dali::Property::Map *arg1 = 0 ;
22343   Dali::PropertyBuffer result;
22344
22345   arg1 = (Dali::Property::Map *)jarg1;
22346   if (!arg1) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22348     return 0;
22349   }
22350   {
22351     try {
22352       result = Dali::PropertyBuffer::New(*arg1);
22353     } catch (std::out_of_range& e) {
22354       {
22355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22356       };
22357     } catch (std::exception& e) {
22358       {
22359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22360       };
22361     } catch (...) {
22362       {
22363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22364       };
22365     }
22366   }
22367   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22368   return jresult;
22369 }
22370
22371
22372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22373   void * jresult ;
22374   Dali::PropertyBuffer *result = 0 ;
22375
22376   {
22377     try {
22378       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22379     } catch (std::out_of_range& e) {
22380       {
22381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22382       };
22383     } catch (std::exception& e) {
22384       {
22385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22386       };
22387     } catch (...) {
22388       {
22389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22390       };
22391     }
22392   }
22393   jresult = (void *)result;
22394   return jresult;
22395 }
22396
22397
22398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22399   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22400
22401   arg1 = (Dali::PropertyBuffer *)jarg1;
22402   {
22403     try {
22404       delete arg1;
22405     } catch (std::out_of_range& e) {
22406       {
22407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22408       };
22409     } catch (std::exception& e) {
22410       {
22411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22412       };
22413     } catch (...) {
22414       {
22415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22416       };
22417     }
22418   }
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22423   void * jresult ;
22424   Dali::PropertyBuffer *arg1 = 0 ;
22425   Dali::PropertyBuffer *result = 0 ;
22426
22427   arg1 = (Dali::PropertyBuffer *)jarg1;
22428   if (!arg1) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22430     return 0;
22431   }
22432   {
22433     try {
22434       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22435     } catch (std::out_of_range& e) {
22436       {
22437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22438       };
22439     } catch (std::exception& e) {
22440       {
22441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22442       };
22443     } catch (...) {
22444       {
22445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22446       };
22447     }
22448   }
22449   jresult = (void *)result;
22450   return jresult;
22451 }
22452
22453
22454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22455   void * jresult ;
22456   Dali::BaseHandle arg1 ;
22457   Dali::BaseHandle *argp1 ;
22458   Dali::PropertyBuffer result;
22459
22460   argp1 = (Dali::BaseHandle *)jarg1;
22461   if (!argp1) {
22462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22463     return 0;
22464   }
22465   arg1 = *argp1;
22466   {
22467     try {
22468       result = Dali::PropertyBuffer::DownCast(arg1);
22469     } catch (std::out_of_range& e) {
22470       {
22471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22472       };
22473     } catch (std::exception& e) {
22474       {
22475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22476       };
22477     } catch (...) {
22478       {
22479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22480       };
22481     }
22482   }
22483   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22484   return jresult;
22485 }
22486
22487
22488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22489   void * jresult ;
22490   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22491   Dali::PropertyBuffer *arg2 = 0 ;
22492   Dali::PropertyBuffer *result = 0 ;
22493
22494   arg1 = (Dali::PropertyBuffer *)jarg1;
22495   arg2 = (Dali::PropertyBuffer *)jarg2;
22496   if (!arg2) {
22497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22498     return 0;
22499   }
22500   {
22501     try {
22502       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22503     } catch (std::out_of_range& e) {
22504       {
22505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22506       };
22507     } catch (std::exception& e) {
22508       {
22509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22510       };
22511     } catch (...) {
22512       {
22513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22514       };
22515     }
22516   }
22517   jresult = (void *)result;
22518   return jresult;
22519 }
22520
22521
22522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22523   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22524   void *arg2 = (void *) 0 ;
22525   std::size_t arg3 ;
22526
22527   arg1 = (Dali::PropertyBuffer *)jarg1;
22528   arg2 = jarg2;
22529   arg3 = (std::size_t)jarg3;
22530   {
22531     try {
22532       (arg1)->SetData((void const *)arg2,arg3);
22533     } catch (std::out_of_range& e) {
22534       {
22535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22536       };
22537     } catch (std::exception& e) {
22538       {
22539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22540       };
22541     } catch (...) {
22542       {
22543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22544       };
22545     }
22546   }
22547 }
22548
22549
22550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22551   unsigned long jresult ;
22552   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22553   std::size_t result;
22554
22555   arg1 = (Dali::PropertyBuffer *)jarg1;
22556   {
22557     try {
22558       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22559     } catch (std::out_of_range& e) {
22560       {
22561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22562       };
22563     } catch (std::exception& e) {
22564       {
22565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22566       };
22567     } catch (...) {
22568       {
22569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22570       };
22571     }
22572   }
22573   jresult = (unsigned long)result;
22574   return jresult;
22575 }
22576
22577
22578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22579   void * jresult ;
22580   Dali::Geometry result;
22581
22582   {
22583     try {
22584       result = Dali::Geometry::New();
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (...) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22596       };
22597     }
22598   }
22599   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22600   return jresult;
22601 }
22602
22603
22604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22605   void * jresult ;
22606   Dali::Geometry *result = 0 ;
22607
22608   {
22609     try {
22610       result = (Dali::Geometry *)new Dali::Geometry();
22611     } catch (std::out_of_range& e) {
22612       {
22613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22614       };
22615     } catch (std::exception& e) {
22616       {
22617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22618       };
22619     } catch (...) {
22620       {
22621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22622       };
22623     }
22624   }
22625   jresult = (void *)result;
22626   return jresult;
22627 }
22628
22629
22630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22631   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22632
22633   arg1 = (Dali::Geometry *)jarg1;
22634   {
22635     try {
22636       delete arg1;
22637     } catch (std::out_of_range& e) {
22638       {
22639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (std::exception& e) {
22642       {
22643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22644       };
22645     } catch (...) {
22646       {
22647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22648       };
22649     }
22650   }
22651 }
22652
22653
22654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22655   void * jresult ;
22656   Dali::Geometry *arg1 = 0 ;
22657   Dali::Geometry *result = 0 ;
22658
22659   arg1 = (Dali::Geometry *)jarg1;
22660   if (!arg1) {
22661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22662     return 0;
22663   }
22664   {
22665     try {
22666       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (...) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22678       };
22679     }
22680   }
22681   jresult = (void *)result;
22682   return jresult;
22683 }
22684
22685
22686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22687   void * jresult ;
22688   Dali::BaseHandle arg1 ;
22689   Dali::BaseHandle *argp1 ;
22690   Dali::Geometry result;
22691
22692   argp1 = (Dali::BaseHandle *)jarg1;
22693   if (!argp1) {
22694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22695     return 0;
22696   }
22697   arg1 = *argp1;
22698   {
22699     try {
22700       result = Dali::Geometry::DownCast(arg1);
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22708       };
22709     } catch (...) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22712       };
22713     }
22714   }
22715   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22716   return jresult;
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22721   void * jresult ;
22722   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22723   Dali::Geometry *arg2 = 0 ;
22724   Dali::Geometry *result = 0 ;
22725
22726   arg1 = (Dali::Geometry *)jarg1;
22727   arg2 = (Dali::Geometry *)jarg2;
22728   if (!arg2) {
22729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22730     return 0;
22731   }
22732   {
22733     try {
22734       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22735     } catch (std::out_of_range& e) {
22736       {
22737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22738       };
22739     } catch (std::exception& e) {
22740       {
22741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22742       };
22743     } catch (...) {
22744       {
22745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22746       };
22747     }
22748   }
22749   jresult = (void *)result;
22750   return jresult;
22751 }
22752
22753
22754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22755   unsigned long jresult ;
22756   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22757   Dali::PropertyBuffer *arg2 = 0 ;
22758   std::size_t result;
22759
22760   arg1 = (Dali::Geometry *)jarg1;
22761   arg2 = (Dali::PropertyBuffer *)jarg2;
22762   if (!arg2) {
22763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22764     return 0;
22765   }
22766   {
22767     try {
22768       result = (arg1)->AddVertexBuffer(*arg2);
22769     } catch (std::out_of_range& e) {
22770       {
22771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22772       };
22773     } catch (std::exception& e) {
22774       {
22775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22776       };
22777     } catch (...) {
22778       {
22779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22780       };
22781     }
22782   }
22783   jresult = (unsigned long)result;
22784   return jresult;
22785 }
22786
22787
22788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22789   unsigned long jresult ;
22790   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22791   std::size_t result;
22792
22793   arg1 = (Dali::Geometry *)jarg1;
22794   {
22795     try {
22796       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22797     } catch (std::out_of_range& e) {
22798       {
22799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22800       };
22801     } catch (std::exception& e) {
22802       {
22803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (...) {
22806       {
22807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22808       };
22809     }
22810   }
22811   jresult = (unsigned long)result;
22812   return jresult;
22813 }
22814
22815
22816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22817   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22818   std::size_t arg2 ;
22819
22820   arg1 = (Dali::Geometry *)jarg1;
22821   arg2 = (std::size_t)jarg2;
22822   {
22823     try {
22824       (arg1)->RemoveVertexBuffer(arg2);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22832       };
22833     } catch (...) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22836       };
22837     }
22838   }
22839 }
22840
22841
22842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22843   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22844   unsigned short *arg2 = (unsigned short *) 0 ;
22845   size_t arg3 ;
22846
22847   arg1 = (Dali::Geometry *)jarg1;
22848   arg2 = jarg2;
22849   arg3 = (size_t)jarg3;
22850   {
22851     try {
22852       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22853     } catch (std::out_of_range& e) {
22854       {
22855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22856       };
22857     } catch (std::exception& e) {
22858       {
22859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22860       };
22861     } catch (...) {
22862       {
22863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22864       };
22865     }
22866   }
22867
22868
22869 }
22870
22871
22872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22873   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22874   Dali::Geometry::Type arg2 ;
22875
22876   arg1 = (Dali::Geometry *)jarg1;
22877   arg2 = (Dali::Geometry::Type)jarg2;
22878   {
22879     try {
22880       (arg1)->SetType(arg2);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22888       };
22889     } catch (...) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22892       };
22893     }
22894   }
22895 }
22896
22897
22898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22899   int jresult ;
22900   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22901   Dali::Geometry::Type result;
22902
22903   arg1 = (Dali::Geometry *)jarg1;
22904   {
22905     try {
22906       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22907     } catch (std::out_of_range& e) {
22908       {
22909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22910       };
22911     } catch (std::exception& e) {
22912       {
22913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22914       };
22915     } catch (...) {
22916       {
22917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22918       };
22919     }
22920   }
22921   jresult = (int)result;
22922   return jresult;
22923 }
22924
22925
22926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22927   void * jresult ;
22928   Dali::Shader::Hint *result = 0 ;
22929
22930   {
22931     try {
22932       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22933     } catch (std::out_of_range& e) {
22934       {
22935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22936       };
22937     } catch (std::exception& e) {
22938       {
22939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22940       };
22941     } catch (...) {
22942       {
22943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22944       };
22945     }
22946   }
22947   jresult = (void *)result;
22948   return jresult;
22949 }
22950
22951
22952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22953   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22954
22955   arg1 = (Dali::Shader::Hint *)jarg1;
22956   {
22957     try {
22958       delete arg1;
22959     } catch (std::out_of_range& e) {
22960       {
22961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22962       };
22963     } catch (std::exception& e) {
22964       {
22965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22966       };
22967     } catch (...) {
22968       {
22969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22970       };
22971     }
22972   }
22973 }
22974
22975
22976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22977   int jresult ;
22978   int result;
22979
22980   result = (int)Dali::Shader::Property::PROGRAM;
22981   jresult = (int)result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22987   void * jresult ;
22988   Dali::Shader::Property *result = 0 ;
22989
22990   {
22991     try {
22992       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22993     } catch (std::out_of_range& e) {
22994       {
22995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22996       };
22997     } catch (std::exception& e) {
22998       {
22999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23000       };
23001     } catch (...) {
23002       {
23003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23004       };
23005     }
23006   }
23007   jresult = (void *)result;
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23013   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23014
23015   arg1 = (Dali::Shader::Property *)jarg1;
23016   {
23017     try {
23018       delete arg1;
23019     } catch (std::out_of_range& e) {
23020       {
23021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23022       };
23023     } catch (std::exception& e) {
23024       {
23025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23026       };
23027     } catch (...) {
23028       {
23029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23030       };
23031     }
23032   }
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23037   void * jresult ;
23038   std::string *arg1 = 0 ;
23039   std::string *arg2 = 0 ;
23040   Dali::Shader::Hint::Value arg3 ;
23041   Dali::Shader result;
23042
23043   if (!jarg1) {
23044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23045     return 0;
23046   }
23047   std::string arg1_str(jarg1);
23048   arg1 = &arg1_str;
23049   if (!jarg2) {
23050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23051     return 0;
23052   }
23053   std::string arg2_str(jarg2);
23054   arg2 = &arg2_str;
23055   arg3 = (Dali::Shader::Hint::Value)jarg3;
23056   {
23057     try {
23058       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23059     } catch (std::out_of_range& e) {
23060       {
23061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23062       };
23063     } catch (std::exception& e) {
23064       {
23065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23066       };
23067     } catch (...) {
23068       {
23069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23070       };
23071     }
23072   }
23073   jresult = new Dali::Shader((const Dali::Shader &)result);
23074
23075   //argout typemap for const std::string&
23076
23077
23078   //argout typemap for const std::string&
23079
23080   return jresult;
23081 }
23082
23083
23084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23085   void * jresult ;
23086   std::string *arg1 = 0 ;
23087   std::string *arg2 = 0 ;
23088   Dali::Shader result;
23089
23090   if (!jarg1) {
23091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23092     return 0;
23093   }
23094   std::string arg1_str(jarg1);
23095   arg1 = &arg1_str;
23096   if (!jarg2) {
23097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23098     return 0;
23099   }
23100   std::string arg2_str(jarg2);
23101   arg2 = &arg2_str;
23102   {
23103     try {
23104       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23105     } catch (std::out_of_range& e) {
23106       {
23107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23108       };
23109     } catch (std::exception& e) {
23110       {
23111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23112       };
23113     } catch (...) {
23114       {
23115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23116       };
23117     }
23118   }
23119   jresult = new Dali::Shader((const Dali::Shader &)result);
23120
23121   //argout typemap for const std::string&
23122
23123
23124   //argout typemap for const std::string&
23125
23126   return jresult;
23127 }
23128
23129
23130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23131   void * jresult ;
23132   Dali::Shader *result = 0 ;
23133
23134   {
23135     try {
23136       result = (Dali::Shader *)new Dali::Shader();
23137     } catch (std::out_of_range& e) {
23138       {
23139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23140       };
23141     } catch (std::exception& e) {
23142       {
23143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23144       };
23145     } catch (...) {
23146       {
23147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23148       };
23149     }
23150   }
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23157   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23158
23159   arg1 = (Dali::Shader *)jarg1;
23160   {
23161     try {
23162       delete arg1;
23163     } catch (std::out_of_range& e) {
23164       {
23165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23166       };
23167     } catch (std::exception& e) {
23168       {
23169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23170       };
23171     } catch (...) {
23172       {
23173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23174       };
23175     }
23176   }
23177 }
23178
23179
23180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23181   void * jresult ;
23182   Dali::Shader *arg1 = 0 ;
23183   Dali::Shader *result = 0 ;
23184
23185   arg1 = (Dali::Shader *)jarg1;
23186   if (!arg1) {
23187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23188     return 0;
23189   }
23190   {
23191     try {
23192       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23193     } catch (std::out_of_range& e) {
23194       {
23195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23196       };
23197     } catch (std::exception& e) {
23198       {
23199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23200       };
23201     } catch (...) {
23202       {
23203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23204       };
23205     }
23206   }
23207   jresult = (void *)result;
23208   return jresult;
23209 }
23210
23211
23212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23213   void * jresult ;
23214   Dali::BaseHandle arg1 ;
23215   Dali::BaseHandle *argp1 ;
23216   Dali::Shader result;
23217
23218   argp1 = (Dali::BaseHandle *)jarg1;
23219   if (!argp1) {
23220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23221     return 0;
23222   }
23223   arg1 = *argp1;
23224   {
23225     try {
23226       result = Dali::Shader::DownCast(arg1);
23227     } catch (std::out_of_range& e) {
23228       {
23229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23230       };
23231     } catch (std::exception& e) {
23232       {
23233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23234       };
23235     } catch (...) {
23236       {
23237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23238       };
23239     }
23240   }
23241   jresult = new Dali::Shader((const Dali::Shader &)result);
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23247   void * jresult ;
23248   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23249   Dali::Shader *arg2 = 0 ;
23250   Dali::Shader *result = 0 ;
23251
23252   arg1 = (Dali::Shader *)jarg1;
23253   arg2 = (Dali::Shader *)jarg2;
23254   if (!arg2) {
23255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23256     return 0;
23257   }
23258   {
23259     try {
23260       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23261     } catch (std::out_of_range& e) {
23262       {
23263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23264       };
23265     } catch (std::exception& e) {
23266       {
23267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23268       };
23269     } catch (...) {
23270       {
23271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23272       };
23273     }
23274   }
23275   jresult = (void *)result;
23276   return jresult;
23277 }
23278
23279
23280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23281   int jresult ;
23282   int result;
23283
23284   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23285   jresult = (int)result;
23286   return jresult;
23287 }
23288
23289
23290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23291   int jresult ;
23292   int result;
23293
23294   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23295   jresult = (int)result;
23296   return jresult;
23297 }
23298
23299
23300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23301   int jresult ;
23302   int result;
23303
23304   result = (int)Dali::Renderer::Property::BLEND_MODE;
23305   jresult = (int)result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23311   int jresult ;
23312   int result;
23313
23314   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23315   jresult = (int)result;
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23321   int jresult ;
23322   int result;
23323
23324   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23325   jresult = (int)result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23331   int jresult ;
23332   int result;
23333
23334   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23335   jresult = (int)result;
23336   return jresult;
23337 }
23338
23339
23340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23341   int jresult ;
23342   int result;
23343
23344   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23345   jresult = (int)result;
23346   return jresult;
23347 }
23348
23349
23350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23351   int jresult ;
23352   int result;
23353
23354   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23355   jresult = (int)result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23361   int jresult ;
23362   int result;
23363
23364   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23365   jresult = (int)result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23371   int jresult ;
23372   int result;
23373
23374   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23375   jresult = (int)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::RENDER_MODE;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23521   void * jresult ;
23522   Dali::Renderer::Property *result = 0 ;
23523
23524   {
23525     try {
23526       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23527     } catch (std::out_of_range& e) {
23528       {
23529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23530       };
23531     } catch (std::exception& e) {
23532       {
23533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23534       };
23535     } catch (...) {
23536       {
23537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23538       };
23539     }
23540   }
23541   jresult = (void *)result;
23542   return jresult;
23543 }
23544
23545
23546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23547   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23548
23549   arg1 = (Dali::Renderer::Property *)jarg1;
23550   {
23551     try {
23552       delete arg1;
23553     } catch (std::out_of_range& e) {
23554       {
23555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23556       };
23557     } catch (std::exception& e) {
23558       {
23559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23560       };
23561     } catch (...) {
23562       {
23563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23564       };
23565     }
23566   }
23567 }
23568
23569
23570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23571   void * jresult ;
23572   Dali::Geometry *arg1 = 0 ;
23573   Dali::Shader *arg2 = 0 ;
23574   Dali::Renderer result;
23575
23576   arg1 = (Dali::Geometry *)jarg1;
23577   if (!arg1) {
23578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23579     return 0;
23580   }
23581   arg2 = (Dali::Shader *)jarg2;
23582   if (!arg2) {
23583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23584     return 0;
23585   }
23586   {
23587     try {
23588       result = Dali::Renderer::New(*arg1,*arg2);
23589     } catch (std::out_of_range& e) {
23590       {
23591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23592       };
23593     } catch (std::exception& e) {
23594       {
23595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23596       };
23597     } catch (...) {
23598       {
23599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23600       };
23601     }
23602   }
23603   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23604   return jresult;
23605 }
23606
23607
23608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23609   void * jresult ;
23610   Dali::Renderer *result = 0 ;
23611
23612   {
23613     try {
23614       result = (Dali::Renderer *)new Dali::Renderer();
23615     } catch (std::out_of_range& e) {
23616       {
23617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23618       };
23619     } catch (std::exception& e) {
23620       {
23621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23622       };
23623     } catch (...) {
23624       {
23625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23626       };
23627     }
23628   }
23629   jresult = (void *)result;
23630   return jresult;
23631 }
23632
23633
23634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23635   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23636
23637   arg1 = (Dali::Renderer *)jarg1;
23638   {
23639     try {
23640       delete arg1;
23641     } catch (std::out_of_range& e) {
23642       {
23643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23644       };
23645     } catch (std::exception& e) {
23646       {
23647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23648       };
23649     } catch (...) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23652       };
23653     }
23654   }
23655 }
23656
23657
23658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23659   void * jresult ;
23660   Dali::Renderer *arg1 = 0 ;
23661   Dali::Renderer *result = 0 ;
23662
23663   arg1 = (Dali::Renderer *)jarg1;
23664   if (!arg1) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (...) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23682       };
23683     }
23684   }
23685   jresult = (void *)result;
23686   return jresult;
23687 }
23688
23689
23690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23691   void * jresult ;
23692   Dali::BaseHandle arg1 ;
23693   Dali::BaseHandle *argp1 ;
23694   Dali::Renderer result;
23695
23696   argp1 = (Dali::BaseHandle *)jarg1;
23697   if (!argp1) {
23698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23699     return 0;
23700   }
23701   arg1 = *argp1;
23702   {
23703     try {
23704       result = Dali::Renderer::DownCast(arg1);
23705     } catch (std::out_of_range& e) {
23706       {
23707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23708       };
23709     } catch (std::exception& e) {
23710       {
23711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23712       };
23713     } catch (...) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23716       };
23717     }
23718   }
23719   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23720   return jresult;
23721 }
23722
23723
23724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23725   void * jresult ;
23726   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23727   Dali::Renderer *arg2 = 0 ;
23728   Dali::Renderer *result = 0 ;
23729
23730   arg1 = (Dali::Renderer *)jarg1;
23731   arg2 = (Dali::Renderer *)jarg2;
23732   if (!arg2) {
23733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23734     return 0;
23735   }
23736   {
23737     try {
23738       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23739     } catch (std::out_of_range& e) {
23740       {
23741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23742       };
23743     } catch (std::exception& e) {
23744       {
23745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (...) {
23748       {
23749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23750       };
23751     }
23752   }
23753   jresult = (void *)result;
23754   return jresult;
23755 }
23756
23757
23758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23759   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23760   Dali::Geometry *arg2 = 0 ;
23761
23762   arg1 = (Dali::Renderer *)jarg1;
23763   arg2 = (Dali::Geometry *)jarg2;
23764   if (!arg2) {
23765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23766     return ;
23767   }
23768   {
23769     try {
23770       (arg1)->SetGeometry(*arg2);
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23782       };
23783     }
23784   }
23785 }
23786
23787
23788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23789   void * jresult ;
23790   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23791   Dali::Geometry result;
23792
23793   arg1 = (Dali::Renderer *)jarg1;
23794   {
23795     try {
23796       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23797     } catch (std::out_of_range& e) {
23798       {
23799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23800       };
23801     } catch (std::exception& e) {
23802       {
23803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23804       };
23805     } catch (...) {
23806       {
23807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23808       };
23809     }
23810   }
23811   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23812   return jresult;
23813 }
23814
23815
23816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23817   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23818   int arg2 ;
23819   int arg3 ;
23820
23821   arg1 = (Dali::Renderer *)jarg1;
23822   arg2 = (int)jarg2;
23823   arg3 = (int)jarg3;
23824   {
23825     try {
23826       (arg1)->SetIndexRange(arg2,arg3);
23827     } catch (std::out_of_range& e) {
23828       {
23829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23830       };
23831     } catch (std::exception& e) {
23832       {
23833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23834       };
23835     } catch (...) {
23836       {
23837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23838       };
23839     }
23840   }
23841 }
23842
23843
23844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23845   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23846   Dali::TextureSet *arg2 = 0 ;
23847
23848   arg1 = (Dali::Renderer *)jarg1;
23849   arg2 = (Dali::TextureSet *)jarg2;
23850   if (!arg2) {
23851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23852     return ;
23853   }
23854   {
23855     try {
23856       (arg1)->SetTextures(*arg2);
23857     } catch (std::out_of_range& e) {
23858       {
23859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23860       };
23861     } catch (std::exception& e) {
23862       {
23863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23864       };
23865     } catch (...) {
23866       {
23867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23868       };
23869     }
23870   }
23871 }
23872
23873
23874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23875   void * jresult ;
23876   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23877   Dali::TextureSet result;
23878
23879   arg1 = (Dali::Renderer *)jarg1;
23880   {
23881     try {
23882       result = ((Dali::Renderer const *)arg1)->GetTextures();
23883     } catch (std::out_of_range& e) {
23884       {
23885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23886       };
23887     } catch (std::exception& e) {
23888       {
23889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23890       };
23891     } catch (...) {
23892       {
23893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23894       };
23895     }
23896   }
23897   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23898   return jresult;
23899 }
23900
23901
23902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23903   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23904   Dali::Shader *arg2 = 0 ;
23905
23906   arg1 = (Dali::Renderer *)jarg1;
23907   arg2 = (Dali::Shader *)jarg2;
23908   if (!arg2) {
23909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23910     return ;
23911   }
23912   {
23913     try {
23914       (arg1)->SetShader(*arg2);
23915     } catch (std::out_of_range& e) {
23916       {
23917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23918       };
23919     } catch (std::exception& e) {
23920       {
23921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23922       };
23923     } catch (...) {
23924       {
23925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23926       };
23927     }
23928   }
23929 }
23930
23931
23932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23933   void * jresult ;
23934   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23935   Dali::Shader result;
23936
23937   arg1 = (Dali::Renderer *)jarg1;
23938   {
23939     try {
23940       result = ((Dali::Renderer const *)arg1)->GetShader();
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23952       };
23953     }
23954   }
23955   jresult = new Dali::Shader((const Dali::Shader &)result);
23956   return jresult;
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23961   void * jresult ;
23962   Dali::FrameBuffer::Attachment *result = 0 ;
23963
23964   {
23965     try {
23966       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23967     } catch (std::out_of_range& e) {
23968       {
23969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (std::exception& e) {
23972       {
23973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (...) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23978       };
23979     }
23980   }
23981   jresult = (void *)result;
23982   return jresult;
23983 }
23984
23985
23986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23987   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23988
23989   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23990   {
23991     try {
23992       delete arg1;
23993     } catch (std::out_of_range& e) {
23994       {
23995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23996       };
23997     } catch (std::exception& e) {
23998       {
23999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24000       };
24001     } catch (...) {
24002       {
24003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24004       };
24005     }
24006   }
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24011   void * jresult ;
24012   unsigned int arg1 ;
24013   unsigned int arg2 ;
24014   unsigned int arg3 ;
24015   Dali::FrameBuffer result;
24016
24017   arg1 = (unsigned int)jarg1;
24018   arg2 = (unsigned int)jarg2;
24019   arg3 = (unsigned int)jarg3;
24020   {
24021     try {
24022       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24023     } catch (std::out_of_range& e) {
24024       {
24025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24026       };
24027     } catch (std::exception& e) {
24028       {
24029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24030       };
24031     } catch (...) {
24032       {
24033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24034       };
24035     }
24036   }
24037   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24038   return jresult;
24039 }
24040
24041
24042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24043   void * jresult ;
24044   Dali::FrameBuffer *result = 0 ;
24045
24046   {
24047     try {
24048       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24049     } catch (std::out_of_range& e) {
24050       {
24051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24052       };
24053     } catch (std::exception& e) {
24054       {
24055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24056       };
24057     } catch (...) {
24058       {
24059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24060       };
24061     }
24062   }
24063   jresult = (void *)result;
24064   return jresult;
24065 }
24066
24067
24068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24069   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24070
24071   arg1 = (Dali::FrameBuffer *)jarg1;
24072   {
24073     try {
24074       delete arg1;
24075     } catch (std::out_of_range& e) {
24076       {
24077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24078       };
24079     } catch (std::exception& e) {
24080       {
24081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24082       };
24083     } catch (...) {
24084       {
24085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24086       };
24087     }
24088   }
24089 }
24090
24091
24092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24093   void * jresult ;
24094   Dali::FrameBuffer *arg1 = 0 ;
24095   Dali::FrameBuffer *result = 0 ;
24096
24097   arg1 = (Dali::FrameBuffer *)jarg1;
24098   if (!arg1) {
24099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24100     return 0;
24101   }
24102   {
24103     try {
24104       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24105     } catch (std::out_of_range& e) {
24106       {
24107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24108       };
24109     } catch (std::exception& e) {
24110       {
24111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24112       };
24113     } catch (...) {
24114       {
24115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24116       };
24117     }
24118   }
24119   jresult = (void *)result;
24120   return jresult;
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24125   void * jresult ;
24126   Dali::BaseHandle arg1 ;
24127   Dali::BaseHandle *argp1 ;
24128   Dali::FrameBuffer result;
24129
24130   argp1 = (Dali::BaseHandle *)jarg1;
24131   if (!argp1) {
24132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24133     return 0;
24134   }
24135   arg1 = *argp1;
24136   {
24137     try {
24138       result = Dali::FrameBuffer::DownCast(arg1);
24139     } catch (std::out_of_range& e) {
24140       {
24141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24142       };
24143     } catch (std::exception& e) {
24144       {
24145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24146       };
24147     } catch (...) {
24148       {
24149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24150       };
24151     }
24152   }
24153   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24159   void * jresult ;
24160   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24161   Dali::FrameBuffer *arg2 = 0 ;
24162   Dali::FrameBuffer *result = 0 ;
24163
24164   arg1 = (Dali::FrameBuffer *)jarg1;
24165   arg2 = (Dali::FrameBuffer *)jarg2;
24166   if (!arg2) {
24167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24168     return 0;
24169   }
24170   {
24171     try {
24172       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24173     } catch (std::out_of_range& e) {
24174       {
24175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24176       };
24177     } catch (std::exception& e) {
24178       {
24179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24180       };
24181     } catch (...) {
24182       {
24183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24184       };
24185     }
24186   }
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24193   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24194   Dali::Texture *arg2 = 0 ;
24195
24196   arg1 = (Dali::FrameBuffer *)jarg1;
24197   arg2 = (Dali::Texture *)jarg2;
24198   if (!arg2) {
24199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24200     return ;
24201   }
24202   {
24203     try {
24204       (arg1)->AttachColorTexture(*arg2);
24205     } catch (std::out_of_range& e) {
24206       {
24207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24208       };
24209     } catch (std::exception& e) {
24210       {
24211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24212       };
24213     } catch (...) {
24214       {
24215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24216       };
24217     }
24218   }
24219 }
24220
24221
24222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24223   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24224   Dali::Texture *arg2 = 0 ;
24225   unsigned int arg3 ;
24226   unsigned int arg4 ;
24227
24228   arg1 = (Dali::FrameBuffer *)jarg1;
24229   arg2 = (Dali::Texture *)jarg2;
24230   if (!arg2) {
24231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24232     return ;
24233   }
24234   arg3 = (unsigned int)jarg3;
24235   arg4 = (unsigned int)jarg4;
24236   {
24237     try {
24238       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24250       };
24251     }
24252   }
24253 }
24254
24255
24256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24257   void * jresult ;
24258   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24259   Dali::Texture result;
24260
24261   arg1 = (Dali::FrameBuffer *)jarg1;
24262   {
24263     try {
24264       result = (arg1)->GetColorTexture();
24265     } catch (std::out_of_range& e) {
24266       {
24267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24268       };
24269     } catch (std::exception& e) {
24270       {
24271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24272       };
24273     } catch (...) {
24274       {
24275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24276       };
24277     }
24278   }
24279   jresult = new Dali::Texture((const Dali::Texture &)result);
24280   return jresult;
24281 }
24282
24283
24284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24285   void * jresult ;
24286   Dali::RenderTaskList *result = 0 ;
24287
24288   {
24289     try {
24290       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24291     } catch (std::out_of_range& e) {
24292       {
24293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24294       };
24295     } catch (std::exception& e) {
24296       {
24297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24298       };
24299     } catch (...) {
24300       {
24301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24302       };
24303     }
24304   }
24305   jresult = (void *)result;
24306   return jresult;
24307 }
24308
24309
24310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24311   void * jresult ;
24312   Dali::BaseHandle arg1 ;
24313   Dali::BaseHandle *argp1 ;
24314   Dali::RenderTaskList result;
24315
24316   argp1 = (Dali::BaseHandle *)jarg1;
24317   if (!argp1) {
24318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24319     return 0;
24320   }
24321   arg1 = *argp1;
24322   {
24323     try {
24324       result = Dali::RenderTaskList::DownCast(arg1);
24325     } catch (std::out_of_range& e) {
24326       {
24327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24328       };
24329     } catch (std::exception& e) {
24330       {
24331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24332       };
24333     } catch (...) {
24334       {
24335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24336       };
24337     }
24338   }
24339   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24345   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24346
24347   arg1 = (Dali::RenderTaskList *)jarg1;
24348   {
24349     try {
24350       delete arg1;
24351     } catch (std::out_of_range& e) {
24352       {
24353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24354       };
24355     } catch (std::exception& e) {
24356       {
24357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24358       };
24359     } catch (...) {
24360       {
24361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24362       };
24363     }
24364   }
24365 }
24366
24367
24368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24369   void * jresult ;
24370   Dali::RenderTaskList *arg1 = 0 ;
24371   Dali::RenderTaskList *result = 0 ;
24372
24373   arg1 = (Dali::RenderTaskList *)jarg1;
24374   if (!arg1) {
24375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24376     return 0;
24377   }
24378   {
24379     try {
24380       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24381     } catch (std::out_of_range& e) {
24382       {
24383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24384       };
24385     } catch (std::exception& e) {
24386       {
24387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (...) {
24390       {
24391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24392       };
24393     }
24394   }
24395   jresult = (void *)result;
24396   return jresult;
24397 }
24398
24399
24400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24401   void * jresult ;
24402   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24403   Dali::RenderTaskList *arg2 = 0 ;
24404   Dali::RenderTaskList *result = 0 ;
24405
24406   arg1 = (Dali::RenderTaskList *)jarg1;
24407   arg2 = (Dali::RenderTaskList *)jarg2;
24408   if (!arg2) {
24409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24410     return 0;
24411   }
24412   {
24413     try {
24414       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24415     } catch (std::out_of_range& e) {
24416       {
24417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24418       };
24419     } catch (std::exception& e) {
24420       {
24421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24422       };
24423     } catch (...) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24426       };
24427     }
24428   }
24429   jresult = (void *)result;
24430   return jresult;
24431 }
24432
24433
24434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24435   void * jresult ;
24436   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24437   Dali::RenderTask result;
24438
24439   arg1 = (Dali::RenderTaskList *)jarg1;
24440   {
24441     try {
24442       result = (arg1)->CreateTask();
24443     } catch (std::out_of_range& e) {
24444       {
24445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24446       };
24447     } catch (std::exception& e) {
24448       {
24449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24450       };
24451     } catch (...) {
24452       {
24453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24454       };
24455     }
24456   }
24457   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24458   return jresult;
24459 }
24460
24461
24462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24463   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24464   Dali::RenderTask arg2 ;
24465   Dali::RenderTask *argp2 ;
24466
24467   arg1 = (Dali::RenderTaskList *)jarg1;
24468   argp2 = (Dali::RenderTask *)jarg2;
24469   if (!argp2) {
24470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24471     return ;
24472   }
24473   arg2 = *argp2;
24474   {
24475     try {
24476       (arg1)->RemoveTask(arg2);
24477     } catch (std::out_of_range& e) {
24478       {
24479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24480       };
24481     } catch (std::exception& e) {
24482       {
24483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24484       };
24485     } catch (...) {
24486       {
24487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24488       };
24489     }
24490   }
24491 }
24492
24493
24494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24495   unsigned int jresult ;
24496   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24497   unsigned int result;
24498
24499   arg1 = (Dali::RenderTaskList *)jarg1;
24500   {
24501     try {
24502       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24503     } catch (std::out_of_range& e) {
24504       {
24505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24506       };
24507     } catch (std::exception& e) {
24508       {
24509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24510       };
24511     } catch (...) {
24512       {
24513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24514       };
24515     }
24516   }
24517   jresult = result;
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24523   void * jresult ;
24524   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24525   unsigned int arg2 ;
24526   Dali::RenderTask result;
24527
24528   arg1 = (Dali::RenderTaskList *)jarg1;
24529   arg2 = (unsigned int)jarg2;
24530   {
24531     try {
24532       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24533     } catch (std::out_of_range& e) {
24534       {
24535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (std::exception& e) {
24538       {
24539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24553   int jresult ;
24554   int result;
24555
24556   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24557   jresult = (int)result;
24558   return jresult;
24559 }
24560
24561
24562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24563   int jresult ;
24564   int result;
24565
24566   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24567   jresult = (int)result;
24568   return jresult;
24569 }
24570
24571
24572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24573   int jresult ;
24574   int result;
24575
24576   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24577   jresult = (int)result;
24578   return jresult;
24579 }
24580
24581
24582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24583   int jresult ;
24584   int result;
24585
24586   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24587   jresult = (int)result;
24588   return jresult;
24589 }
24590
24591
24592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24593   void * jresult ;
24594   Dali::RenderTask::Property *result = 0 ;
24595
24596   {
24597     try {
24598       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24599     } catch (std::out_of_range& e) {
24600       {
24601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (std::exception& e) {
24604       {
24605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (...) {
24608       {
24609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24610       };
24611     }
24612   }
24613   jresult = (void *)result;
24614   return jresult;
24615 }
24616
24617
24618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24619   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24620
24621   arg1 = (Dali::RenderTask::Property *)jarg1;
24622   {
24623     try {
24624       delete arg1;
24625     } catch (std::out_of_range& e) {
24626       {
24627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24628       };
24629     } catch (std::exception& e) {
24630       {
24631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24632       };
24633     } catch (...) {
24634       {
24635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24636       };
24637     }
24638   }
24639 }
24640
24641
24642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24643   void * jresult ;
24644   bool (*result)(Dali::Vector2 &) = 0 ;
24645
24646   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24647   jresult = (void *)result;
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24653   void * jresult ;
24654   bool (*result)(Dali::Vector2 &) = 0 ;
24655
24656   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24657   jresult = (void *)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24663   unsigned int jresult ;
24664   bool result;
24665
24666   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24667   jresult = result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24673   unsigned int jresult ;
24674   bool result;
24675
24676   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24677   jresult = result;
24678   return jresult;
24679 }
24680
24681
24682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24683   void * jresult ;
24684   Dali::Vector4 *result = 0 ;
24685
24686   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24687   jresult = (void *)result;
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24693   unsigned int jresult ;
24694   bool result;
24695
24696   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24697   jresult = result;
24698   return jresult;
24699 }
24700
24701
24702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24703   unsigned int jresult ;
24704   bool result;
24705
24706   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24713   unsigned int jresult ;
24714   unsigned int result;
24715
24716   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24717   jresult = result;
24718   return jresult;
24719 }
24720
24721
24722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24723   void * jresult ;
24724   Dali::RenderTask *result = 0 ;
24725
24726   {
24727     try {
24728       result = (Dali::RenderTask *)new Dali::RenderTask();
24729     } catch (std::out_of_range& e) {
24730       {
24731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24732       };
24733     } catch (std::exception& e) {
24734       {
24735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24736       };
24737     } catch (...) {
24738       {
24739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24740       };
24741     }
24742   }
24743   jresult = (void *)result;
24744   return jresult;
24745 }
24746
24747
24748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24749   void * jresult ;
24750   Dali::BaseHandle arg1 ;
24751   Dali::BaseHandle *argp1 ;
24752   Dali::RenderTask result;
24753
24754   argp1 = (Dali::BaseHandle *)jarg1;
24755   if (!argp1) {
24756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24757     return 0;
24758   }
24759   arg1 = *argp1;
24760   {
24761     try {
24762       result = Dali::RenderTask::DownCast(arg1);
24763     } catch (std::out_of_range& e) {
24764       {
24765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24766       };
24767     } catch (std::exception& e) {
24768       {
24769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24770       };
24771     } catch (...) {
24772       {
24773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24774       };
24775     }
24776   }
24777   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24783   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24784
24785   arg1 = (Dali::RenderTask *)jarg1;
24786   {
24787     try {
24788       delete arg1;
24789     } catch (std::out_of_range& e) {
24790       {
24791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24792       };
24793     } catch (std::exception& e) {
24794       {
24795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24796       };
24797     } catch (...) {
24798       {
24799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24800       };
24801     }
24802   }
24803 }
24804
24805
24806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24807   void * jresult ;
24808   Dali::RenderTask *arg1 = 0 ;
24809   Dali::RenderTask *result = 0 ;
24810
24811   arg1 = (Dali::RenderTask *)jarg1;
24812   if (!arg1) {
24813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24814     return 0;
24815   }
24816   {
24817     try {
24818       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24819     } catch (std::out_of_range& e) {
24820       {
24821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24822       };
24823     } catch (std::exception& e) {
24824       {
24825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24826       };
24827     } catch (...) {
24828       {
24829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24830       };
24831     }
24832   }
24833   jresult = (void *)result;
24834   return jresult;
24835 }
24836
24837
24838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24839   void * jresult ;
24840   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24841   Dali::RenderTask *arg2 = 0 ;
24842   Dali::RenderTask *result = 0 ;
24843
24844   arg1 = (Dali::RenderTask *)jarg1;
24845   arg2 = (Dali::RenderTask *)jarg2;
24846   if (!arg2) {
24847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24848     return 0;
24849   }
24850   {
24851     try {
24852       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24853     } catch (std::out_of_range& e) {
24854       {
24855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (std::exception& e) {
24858       {
24859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867   jresult = (void *)result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24873   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24874   Dali::Actor arg2 ;
24875   Dali::Actor *argp2 ;
24876
24877   arg1 = (Dali::RenderTask *)jarg1;
24878   argp2 = (Dali::Actor *)jarg2;
24879   if (!argp2) {
24880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24881     return ;
24882   }
24883   arg2 = *argp2;
24884   {
24885     try {
24886       (arg1)->SetSourceActor(arg2);
24887     } catch (std::out_of_range& e) {
24888       {
24889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (std::exception& e) {
24892       {
24893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24898       };
24899     }
24900   }
24901 }
24902
24903
24904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24905   void * jresult ;
24906   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24907   Dali::Actor result;
24908
24909   arg1 = (Dali::RenderTask *)jarg1;
24910   {
24911     try {
24912       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24913     } catch (std::out_of_range& e) {
24914       {
24915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24916       };
24917     } catch (std::exception& e) {
24918       {
24919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24920       };
24921     } catch (...) {
24922       {
24923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24924       };
24925     }
24926   }
24927   jresult = new Dali::Actor((const Dali::Actor &)result);
24928   return jresult;
24929 }
24930
24931
24932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24934   bool arg2 ;
24935
24936   arg1 = (Dali::RenderTask *)jarg1;
24937   arg2 = jarg2 ? true : false;
24938   {
24939     try {
24940       (arg1)->SetExclusive(arg2);
24941     } catch (std::out_of_range& e) {
24942       {
24943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24944       };
24945     } catch (std::exception& e) {
24946       {
24947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24948       };
24949     } catch (...) {
24950       {
24951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24952       };
24953     }
24954   }
24955 }
24956
24957
24958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24959   unsigned int jresult ;
24960   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24961   bool result;
24962
24963   arg1 = (Dali::RenderTask *)jarg1;
24964   {
24965     try {
24966       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24967     } catch (std::out_of_range& e) {
24968       {
24969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24970       };
24971     } catch (std::exception& e) {
24972       {
24973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24974       };
24975     } catch (...) {
24976       {
24977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24978       };
24979     }
24980   }
24981   jresult = result;
24982   return jresult;
24983 }
24984
24985
24986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24987   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24988   bool arg2 ;
24989
24990   arg1 = (Dali::RenderTask *)jarg1;
24991   arg2 = jarg2 ? true : false;
24992   {
24993     try {
24994       (arg1)->SetInputEnabled(arg2);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (...) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25006       };
25007     }
25008   }
25009 }
25010
25011
25012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25013   unsigned int jresult ;
25014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25015   bool result;
25016
25017   arg1 = (Dali::RenderTask *)jarg1;
25018   {
25019     try {
25020       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25032       };
25033     }
25034   }
25035   jresult = result;
25036   return jresult;
25037 }
25038
25039
25040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25042   Dali::CameraActor arg2 ;
25043   Dali::CameraActor *argp2 ;
25044
25045   arg1 = (Dali::RenderTask *)jarg1;
25046   argp2 = (Dali::CameraActor *)jarg2;
25047   if (!argp2) {
25048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25049     return ;
25050   }
25051   arg2 = *argp2;
25052   {
25053     try {
25054       (arg1)->SetCameraActor(arg2);
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25066       };
25067     }
25068   }
25069 }
25070
25071
25072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25073   void * jresult ;
25074   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25075   Dali::CameraActor result;
25076
25077   arg1 = (Dali::RenderTask *)jarg1;
25078   {
25079     try {
25080       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25081     } catch (std::out_of_range& e) {
25082       {
25083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25084       };
25085     } catch (std::exception& e) {
25086       {
25087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (...) {
25090       {
25091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25092       };
25093     }
25094   }
25095   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25096   return jresult;
25097 }
25098
25099
25100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25101   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25102   Dali::FrameBufferImage arg2 ;
25103   Dali::FrameBufferImage *argp2 ;
25104
25105   arg1 = (Dali::RenderTask *)jarg1;
25106   argp2 = (Dali::FrameBufferImage *)jarg2;
25107   if (!argp2) {
25108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25109     return ;
25110   }
25111   arg2 = *argp2;
25112   {
25113     try {
25114       (arg1)->SetTargetFrameBuffer(arg2);
25115     } catch (std::out_of_range& e) {
25116       {
25117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25118       };
25119     } catch (std::exception& e) {
25120       {
25121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25122       };
25123     } catch (...) {
25124       {
25125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25126       };
25127     }
25128   }
25129 }
25130
25131
25132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25133   void * jresult ;
25134   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25135   Dali::FrameBufferImage result;
25136
25137   arg1 = (Dali::RenderTask *)jarg1;
25138   {
25139     try {
25140       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25141     } catch (std::out_of_range& e) {
25142       {
25143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25144       };
25145     } catch (std::exception& e) {
25146       {
25147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25148       };
25149     } catch (...) {
25150       {
25151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25152       };
25153     }
25154   }
25155   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25156   return jresult;
25157 }
25158
25159
25160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25161   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25162   Dali::FrameBuffer arg2 ;
25163   Dali::FrameBuffer *argp2 ;
25164
25165   arg1 = (Dali::RenderTask *)jarg1;
25166   argp2 = (Dali::FrameBuffer *)jarg2;
25167   if (!argp2) {
25168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25169     return ;
25170   }
25171   arg2 = *argp2;
25172   {
25173     try {
25174       (arg1)->SetFrameBuffer(arg2);
25175     } catch (std::out_of_range& e) {
25176       {
25177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25178       };
25179     } catch (std::exception& e) {
25180       {
25181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25182       };
25183     } catch (...) {
25184       {
25185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25186       };
25187     }
25188   }
25189 }
25190
25191
25192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25193   void * jresult ;
25194   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25195   Dali::FrameBuffer result;
25196
25197   arg1 = (Dali::RenderTask *)jarg1;
25198   {
25199     try {
25200       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25201     } catch (std::out_of_range& e) {
25202       {
25203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25204       };
25205     } catch (std::exception& e) {
25206       {
25207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25208       };
25209     } catch (...) {
25210       {
25211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25212       };
25213     }
25214   }
25215   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25216   return jresult;
25217 }
25218
25219
25220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25222   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25223
25224   arg1 = (Dali::RenderTask *)jarg1;
25225   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25226   {
25227     try {
25228       (arg1)->SetScreenToFrameBufferFunction(arg2);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25236       };
25237     } catch (...) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25240       };
25241     }
25242   }
25243 }
25244
25245
25246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25247   void * jresult ;
25248   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25249   Dali::RenderTask::ScreenToFrameBufferFunction result;
25250
25251   arg1 = (Dali::RenderTask *)jarg1;
25252   {
25253     try {
25254       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25255     } catch (std::out_of_range& e) {
25256       {
25257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25258       };
25259     } catch (std::exception& e) {
25260       {
25261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25266       };
25267     }
25268   }
25269   jresult = (void *)result;
25270   return jresult;
25271 }
25272
25273
25274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25276   Dali::Actor arg2 ;
25277   Dali::Actor *argp2 ;
25278
25279   arg1 = (Dali::RenderTask *)jarg1;
25280   argp2 = (Dali::Actor *)jarg2;
25281   if (!argp2) {
25282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25283     return ;
25284   }
25285   arg2 = *argp2;
25286   {
25287     try {
25288       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25289     } catch (std::out_of_range& e) {
25290       {
25291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25292       };
25293     } catch (std::exception& e) {
25294       {
25295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25296       };
25297     } catch (...) {
25298       {
25299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25300       };
25301     }
25302   }
25303 }
25304
25305
25306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25307   void * jresult ;
25308   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25309   Dali::Actor result;
25310
25311   arg1 = (Dali::RenderTask *)jarg1;
25312   {
25313     try {
25314       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25315     } catch (std::out_of_range& e) {
25316       {
25317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25318       };
25319     } catch (std::exception& e) {
25320       {
25321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25322       };
25323     } catch (...) {
25324       {
25325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25326       };
25327     }
25328   }
25329   jresult = new Dali::Actor((const Dali::Actor &)result);
25330   return jresult;
25331 }
25332
25333
25334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25335   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25336   Dali::Vector2 arg2 ;
25337   Dali::Vector2 *argp2 ;
25338
25339   arg1 = (Dali::RenderTask *)jarg1;
25340   argp2 = (Dali::Vector2 *)jarg2;
25341   if (!argp2) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25343     return ;
25344   }
25345   arg2 = *argp2;
25346   {
25347     try {
25348       (arg1)->SetViewportPosition(arg2);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363 }
25364
25365
25366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25367   void * jresult ;
25368   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25369   Dali::Vector2 result;
25370
25371   arg1 = (Dali::RenderTask *)jarg1;
25372   {
25373     try {
25374       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25375     } catch (std::out_of_range& e) {
25376       {
25377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (std::exception& e) {
25380       {
25381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (...) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25386       };
25387     }
25388   }
25389   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25390   return jresult;
25391 }
25392
25393
25394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25395   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25396   Dali::Vector2 arg2 ;
25397   Dali::Vector2 *argp2 ;
25398
25399   arg1 = (Dali::RenderTask *)jarg1;
25400   argp2 = (Dali::Vector2 *)jarg2;
25401   if (!argp2) {
25402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25403     return ;
25404   }
25405   arg2 = *argp2;
25406   {
25407     try {
25408       (arg1)->SetViewportSize(arg2);
25409     } catch (std::out_of_range& e) {
25410       {
25411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25412       };
25413     } catch (std::exception& e) {
25414       {
25415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25420       };
25421     }
25422   }
25423 }
25424
25425
25426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25427   void * jresult ;
25428   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25429   Dali::Vector2 result;
25430
25431   arg1 = (Dali::RenderTask *)jarg1;
25432   {
25433     try {
25434       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25435     } catch (std::out_of_range& e) {
25436       {
25437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25438       };
25439     } catch (std::exception& e) {
25440       {
25441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25442       };
25443     } catch (...) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25446       };
25447     }
25448   }
25449   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25450   return jresult;
25451 }
25452
25453
25454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25455   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25456   Dali::Viewport arg2 ;
25457   Dali::Viewport *argp2 ;
25458
25459   arg1 = (Dali::RenderTask *)jarg1;
25460   argp2 = (Dali::Viewport *)jarg2;
25461   if (!argp2) {
25462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25463     return ;
25464   }
25465   arg2 = *argp2;
25466   {
25467     try {
25468       (arg1)->SetViewport(arg2);
25469     } catch (std::out_of_range& e) {
25470       {
25471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25472       };
25473     } catch (std::exception& e) {
25474       {
25475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25476       };
25477     } catch (...) {
25478       {
25479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25480       };
25481     }
25482   }
25483 }
25484
25485
25486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25487   void * jresult ;
25488   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25489   Dali::Viewport result;
25490
25491   arg1 = (Dali::RenderTask *)jarg1;
25492   {
25493     try {
25494       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25495     } catch (std::out_of_range& e) {
25496       {
25497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25498       };
25499     } catch (std::exception& e) {
25500       {
25501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (...) {
25504       {
25505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25506       };
25507     }
25508   }
25509   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25510   return jresult;
25511 }
25512
25513
25514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25515   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25516   Dali::Vector4 *arg2 = 0 ;
25517
25518   arg1 = (Dali::RenderTask *)jarg1;
25519   arg2 = (Dali::Vector4 *)jarg2;
25520   if (!arg2) {
25521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25522     return ;
25523   }
25524   {
25525     try {
25526       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25527     } catch (std::out_of_range& e) {
25528       {
25529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25530       };
25531     } catch (std::exception& e) {
25532       {
25533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25534       };
25535     } catch (...) {
25536       {
25537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25538       };
25539     }
25540   }
25541 }
25542
25543
25544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25545   void * jresult ;
25546   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25547   Dali::Vector4 result;
25548
25549   arg1 = (Dali::RenderTask *)jarg1;
25550   {
25551     try {
25552       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25553     } catch (std::out_of_range& e) {
25554       {
25555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (std::exception& e) {
25558       {
25559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25568   return jresult;
25569 }
25570
25571
25572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25574   bool arg2 ;
25575
25576   arg1 = (Dali::RenderTask *)jarg1;
25577   arg2 = jarg2 ? true : false;
25578   {
25579     try {
25580       (arg1)->SetClearEnabled(arg2);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25588       };
25589     } catch (...) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25592       };
25593     }
25594   }
25595 }
25596
25597
25598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25599   unsigned int jresult ;
25600   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25601   bool result;
25602
25603   arg1 = (Dali::RenderTask *)jarg1;
25604   {
25605     try {
25606       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25607     } catch (std::out_of_range& e) {
25608       {
25609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25610       };
25611     } catch (std::exception& e) {
25612       {
25613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25614       };
25615     } catch (...) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25618       };
25619     }
25620   }
25621   jresult = result;
25622   return jresult;
25623 }
25624
25625
25626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25628   bool arg2 ;
25629
25630   arg1 = (Dali::RenderTask *)jarg1;
25631   arg2 = jarg2 ? true : false;
25632   {
25633     try {
25634       (arg1)->SetCullMode(arg2);
25635     } catch (std::out_of_range& e) {
25636       {
25637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25638       };
25639     } catch (std::exception& e) {
25640       {
25641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25642       };
25643     } catch (...) {
25644       {
25645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25646       };
25647     }
25648   }
25649 }
25650
25651
25652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25653   unsigned int jresult ;
25654   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25655   bool result;
25656
25657   arg1 = (Dali::RenderTask *)jarg1;
25658   {
25659     try {
25660       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25661     } catch (std::out_of_range& e) {
25662       {
25663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25664       };
25665     } catch (std::exception& e) {
25666       {
25667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25672       };
25673     }
25674   }
25675   jresult = result;
25676   return jresult;
25677 }
25678
25679
25680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25681   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25682   unsigned int arg2 ;
25683
25684   arg1 = (Dali::RenderTask *)jarg1;
25685   arg2 = (unsigned int)jarg2;
25686   {
25687     try {
25688       (arg1)->SetRefreshRate(arg2);
25689     } catch (std::out_of_range& e) {
25690       {
25691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25692       };
25693     } catch (std::exception& e) {
25694       {
25695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25696       };
25697     } catch (...) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25700       };
25701     }
25702   }
25703 }
25704
25705
25706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25707   unsigned int jresult ;
25708   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25709   unsigned int result;
25710
25711   arg1 = (Dali::RenderTask *)jarg1;
25712   {
25713     try {
25714       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (...) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25726       };
25727     }
25728   }
25729   jresult = result;
25730   return jresult;
25731 }
25732
25733
25734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25735   unsigned int jresult ;
25736   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25737   Dali::Vector3 *arg2 = 0 ;
25738   float *arg3 = 0 ;
25739   float *arg4 = 0 ;
25740   bool result;
25741
25742   arg1 = (Dali::RenderTask *)jarg1;
25743   arg2 = (Dali::Vector3 *)jarg2;
25744   if (!arg2) {
25745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25746     return 0;
25747   }
25748   arg3 = (float *)jarg3;
25749   arg4 = (float *)jarg4;
25750   {
25751     try {
25752       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25753     } catch (std::out_of_range& e) {
25754       {
25755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (std::exception& e) {
25758       {
25759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25764       };
25765     }
25766   }
25767   jresult = result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25773   unsigned int jresult ;
25774   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25775   Dali::Actor arg2 ;
25776   float arg3 ;
25777   float arg4 ;
25778   float *arg5 = 0 ;
25779   float *arg6 = 0 ;
25780   Dali::Actor *argp2 ;
25781   bool result;
25782
25783   arg1 = (Dali::RenderTask *)jarg1;
25784   argp2 = (Dali::Actor *)jarg2;
25785   if (!argp2) {
25786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25787     return 0;
25788   }
25789   arg2 = *argp2;
25790   arg3 = (float)jarg3;
25791   arg4 = (float)jarg4;
25792   arg5 = (float *)jarg5;
25793   arg6 = (float *)jarg6;
25794   {
25795     try {
25796       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25797     } catch (std::out_of_range& e) {
25798       {
25799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25800       };
25801     } catch (std::exception& e) {
25802       {
25803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25804       };
25805     } catch (...) {
25806       {
25807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25808       };
25809     }
25810   }
25811   jresult = result;
25812   return jresult;
25813 }
25814
25815
25816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25817   void * jresult ;
25818   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25819   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25820
25821   arg1 = (Dali::RenderTask *)jarg1;
25822   {
25823     try {
25824       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25825     } catch (std::out_of_range& e) {
25826       {
25827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (std::exception& e) {
25830       {
25831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839   jresult = (void *)result;
25840   return jresult;
25841 }
25842
25843
25844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25845   void * jresult ;
25846   int arg1 ;
25847   Dali::TouchPoint::State arg2 ;
25848   float arg3 ;
25849   float arg4 ;
25850   Dali::TouchPoint *result = 0 ;
25851
25852   arg1 = (int)jarg1;
25853   arg2 = (Dali::TouchPoint::State)jarg2;
25854   arg3 = (float)jarg3;
25855   arg4 = (float)jarg4;
25856   {
25857     try {
25858       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25859     } catch (std::out_of_range& e) {
25860       {
25861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (std::exception& e) {
25864       {
25865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25866       };
25867     } catch (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25870       };
25871     }
25872   }
25873   jresult = (void *)result;
25874   return jresult;
25875 }
25876
25877
25878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25879   void * jresult ;
25880   int arg1 ;
25881   Dali::TouchPoint::State arg2 ;
25882   float arg3 ;
25883   float arg4 ;
25884   float arg5 ;
25885   float arg6 ;
25886   Dali::TouchPoint *result = 0 ;
25887
25888   arg1 = (int)jarg1;
25889   arg2 = (Dali::TouchPoint::State)jarg2;
25890   arg3 = (float)jarg3;
25891   arg4 = (float)jarg4;
25892   arg5 = (float)jarg5;
25893   arg6 = (float)jarg6;
25894   {
25895     try {
25896       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25917   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25918
25919   arg1 = (Dali::TouchPoint *)jarg1;
25920   {
25921     try {
25922       delete arg1;
25923     } catch (std::out_of_range& e) {
25924       {
25925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25926       };
25927     } catch (std::exception& e) {
25928       {
25929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25930       };
25931     } catch (...) {
25932       {
25933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25934       };
25935     }
25936   }
25937 }
25938
25939
25940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25941   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25942   int arg2 ;
25943
25944   arg1 = (Dali::TouchPoint *)jarg1;
25945   arg2 = (int)jarg2;
25946   if (arg1) (arg1)->deviceId = arg2;
25947 }
25948
25949
25950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25951   int jresult ;
25952   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25953   int result;
25954
25955   arg1 = (Dali::TouchPoint *)jarg1;
25956   result = (int) ((arg1)->deviceId);
25957   jresult = result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25963   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25964   Dali::TouchPoint::State arg2 ;
25965
25966   arg1 = (Dali::TouchPoint *)jarg1;
25967   arg2 = (Dali::TouchPoint::State)jarg2;
25968   if (arg1) (arg1)->state = arg2;
25969 }
25970
25971
25972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25973   int jresult ;
25974   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25975   Dali::TouchPoint::State result;
25976
25977   arg1 = (Dali::TouchPoint *)jarg1;
25978   result = (Dali::TouchPoint::State) ((arg1)->state);
25979   jresult = (int)result;
25980   return jresult;
25981 }
25982
25983
25984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25985   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25986   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25987
25988   arg1 = (Dali::TouchPoint *)jarg1;
25989   arg2 = (Dali::Actor *)jarg2;
25990   if (arg1) (arg1)->hitActor = *arg2;
25991 }
25992
25993
25994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25995   void * jresult ;
25996   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25997   Dali::Actor *result = 0 ;
25998
25999   arg1 = (Dali::TouchPoint *)jarg1;
26000   result = (Dali::Actor *)& ((arg1)->hitActor);
26001   jresult = (void *)result;
26002   return jresult;
26003 }
26004
26005
26006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26007   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26008   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26009
26010   arg1 = (Dali::TouchPoint *)jarg1;
26011   arg2 = (Dali::Vector2 *)jarg2;
26012   if (arg1) (arg1)->local = *arg2;
26013 }
26014
26015
26016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26017   void * jresult ;
26018   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26019   Dali::Vector2 *result = 0 ;
26020
26021   arg1 = (Dali::TouchPoint *)jarg1;
26022   result = (Dali::Vector2 *)& ((arg1)->local);
26023   jresult = (void *)result;
26024   return jresult;
26025 }
26026
26027
26028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26029   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26030   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26031
26032   arg1 = (Dali::TouchPoint *)jarg1;
26033   arg2 = (Dali::Vector2 *)jarg2;
26034   if (arg1) (arg1)->screen = *arg2;
26035 }
26036
26037
26038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26039   void * jresult ;
26040   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26041   Dali::Vector2 *result = 0 ;
26042
26043   arg1 = (Dali::TouchPoint *)jarg1;
26044   result = (Dali::Vector2 *)& ((arg1)->screen);
26045   jresult = (void *)result;
26046   return jresult;
26047 }
26048
26049
26050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26051   void * jresult ;
26052   Dali::TouchData *result = 0 ;
26053
26054   {
26055     try {
26056       result = (Dali::TouchData *)new Dali::TouchData();
26057     } catch (std::out_of_range& e) {
26058       {
26059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26060       };
26061     } catch (std::exception& e) {
26062       {
26063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26064       };
26065     } catch (...) {
26066       {
26067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26068       };
26069     }
26070   }
26071   jresult = (void *)result;
26072   return jresult;
26073 }
26074
26075
26076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26077   void * jresult ;
26078   Dali::TouchData *arg1 = 0 ;
26079   Dali::TouchData *result = 0 ;
26080
26081   arg1 = (Dali::TouchData *)jarg1;
26082   if (!arg1) {
26083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26084     return 0;
26085   }
26086   {
26087     try {
26088       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26089     } catch (std::out_of_range& e) {
26090       {
26091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26092       };
26093     } catch (std::exception& e) {
26094       {
26095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26096       };
26097     } catch (...) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26100       };
26101     }
26102   }
26103   jresult = (void *)result;
26104   return jresult;
26105 }
26106
26107
26108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26109   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26110
26111   arg1 = (Dali::TouchData *)jarg1;
26112   {
26113     try {
26114       delete arg1;
26115     } catch (std::out_of_range& e) {
26116       {
26117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26118       };
26119     } catch (std::exception& e) {
26120       {
26121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26122       };
26123     } catch (...) {
26124       {
26125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26126       };
26127     }
26128   }
26129 }
26130
26131
26132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26133   void * jresult ;
26134   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26135   Dali::TouchData *arg2 = 0 ;
26136   Dali::TouchData *result = 0 ;
26137
26138   arg1 = (Dali::TouchData *)jarg1;
26139   arg2 = (Dali::TouchData *)jarg2;
26140   if (!arg2) {
26141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26142     return 0;
26143   }
26144   {
26145     try {
26146       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26147     } catch (std::out_of_range& e) {
26148       {
26149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26150       };
26151     } catch (std::exception& e) {
26152       {
26153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26154       };
26155     } catch (...) {
26156       {
26157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26158       };
26159     }
26160   }
26161   jresult = (void *)result;
26162   return jresult;
26163 }
26164
26165
26166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26167   unsigned long jresult ;
26168   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26169   unsigned long result;
26170
26171   arg1 = (Dali::TouchData *)jarg1;
26172   {
26173     try {
26174       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26175     } catch (std::out_of_range& e) {
26176       {
26177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26178       };
26179     } catch (std::exception& e) {
26180       {
26181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26182       };
26183     } catch (...) {
26184       {
26185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26186       };
26187     }
26188   }
26189   jresult = (unsigned long)result;
26190   return jresult;
26191 }
26192
26193
26194 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26195   unsigned long jresult ;
26196   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26197   std::size_t result;
26198
26199   arg1 = (Dali::TouchData *)jarg1;
26200   {
26201     try {
26202       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26203     } catch (std::out_of_range& e) {
26204       {
26205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (std::exception& e) {
26208       {
26209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217   jresult = (unsigned long)result;
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26223   int jresult ;
26224   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26225   std::size_t arg2 ;
26226   int32_t result;
26227
26228   arg1 = (Dali::TouchData *)jarg1;
26229   arg2 = (std::size_t)jarg2;
26230   {
26231     try {
26232       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26240       };
26241     } catch (...) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26244       };
26245     }
26246   }
26247   jresult = result;
26248   return jresult;
26249 }
26250
26251
26252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26253   int jresult ;
26254   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26255   std::size_t arg2 ;
26256   Dali::PointState::Type result;
26257
26258   arg1 = (Dali::TouchData *)jarg1;
26259   arg2 = (std::size_t)jarg2;
26260   {
26261     try {
26262       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26263     } catch (std::out_of_range& e) {
26264       {
26265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26266       };
26267     } catch (std::exception& e) {
26268       {
26269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26270       };
26271     } catch (...) {
26272       {
26273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26274       };
26275     }
26276   }
26277   jresult = (int)result;
26278   return jresult;
26279 }
26280
26281
26282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26283   void * jresult ;
26284   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26285   std::size_t arg2 ;
26286   Dali::Actor result;
26287
26288   arg1 = (Dali::TouchData *)jarg1;
26289   arg2 = (std::size_t)jarg2;
26290   {
26291     try {
26292       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26293     } catch (std::out_of_range& e) {
26294       {
26295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26296       };
26297     } catch (std::exception& e) {
26298       {
26299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26300       };
26301     } catch (...) {
26302       {
26303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26304       };
26305     }
26306   }
26307   jresult = new Dali::Actor((const Dali::Actor &)result);
26308   return jresult;
26309 }
26310
26311
26312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26313   void * jresult ;
26314   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26315   std::size_t arg2 ;
26316   Dali::Vector2 *result = 0 ;
26317
26318   arg1 = (Dali::TouchData *)jarg1;
26319   arg2 = (std::size_t)jarg2;
26320   {
26321     try {
26322       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26323     } catch (std::out_of_range& e) {
26324       {
26325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26326       };
26327     } catch (std::exception& e) {
26328       {
26329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26330       };
26331     } catch (...) {
26332       {
26333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26334       };
26335     }
26336   }
26337   jresult = (void *)result;
26338   return jresult;
26339 }
26340
26341
26342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26343   void * jresult ;
26344   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26345   std::size_t arg2 ;
26346   Dali::Vector2 *result = 0 ;
26347
26348   arg1 = (Dali::TouchData *)jarg1;
26349   arg2 = (std::size_t)jarg2;
26350   {
26351     try {
26352       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26353     } catch (std::out_of_range& e) {
26354       {
26355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26356       };
26357     } catch (std::exception& e) {
26358       {
26359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26360       };
26361     } catch (...) {
26362       {
26363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26364       };
26365     }
26366   }
26367   jresult = (void *)result;
26368   return jresult;
26369 }
26370
26371
26372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26373   float jresult ;
26374   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26375   std::size_t arg2 ;
26376   float result;
26377
26378   arg1 = (Dali::TouchData *)jarg1;
26379   arg2 = (std::size_t)jarg2;
26380   {
26381     try {
26382       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26383     } catch (std::out_of_range& e) {
26384       {
26385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26386       };
26387     } catch (std::exception& e) {
26388       {
26389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26390       };
26391     } catch (...) {
26392       {
26393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26394       };
26395     }
26396   }
26397   jresult = result;
26398   return jresult;
26399 }
26400
26401
26402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26403   void * jresult ;
26404   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26405   std::size_t arg2 ;
26406   Dali::Vector2 *result = 0 ;
26407
26408   arg1 = (Dali::TouchData *)jarg1;
26409   arg2 = (std::size_t)jarg2;
26410   {
26411     try {
26412       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26413     } catch (std::out_of_range& e) {
26414       {
26415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26416       };
26417     } catch (std::exception& e) {
26418       {
26419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26420       };
26421     } catch (...) {
26422       {
26423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26424       };
26425     }
26426   }
26427   jresult = (void *)result;
26428   return jresult;
26429 }
26430
26431
26432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26433   float jresult ;
26434   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26435   std::size_t arg2 ;
26436   float result;
26437
26438   arg1 = (Dali::TouchData *)jarg1;
26439   arg2 = (std::size_t)jarg2;
26440   {
26441     try {
26442       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26443     } catch (std::out_of_range& e) {
26444       {
26445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26446       };
26447     } catch (std::exception& e) {
26448       {
26449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26450       };
26451     } catch (...) {
26452       {
26453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26454       };
26455     }
26456   }
26457   jresult = result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26463   void * jresult ;
26464   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26465   std::size_t arg2 ;
26466   Dali::Degree result;
26467
26468   arg1 = (Dali::TouchData *)jarg1;
26469   arg2 = (std::size_t)jarg2;
26470   {
26471     try {
26472       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26473     } catch (std::out_of_range& e) {
26474       {
26475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26476       };
26477     } catch (std::exception& e) {
26478       {
26479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26484       };
26485     }
26486   }
26487   jresult = new Dali::Degree((const Dali::Degree &)result);
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26493   void * jresult ;
26494   Dali::GestureDetector *result = 0 ;
26495
26496   {
26497     try {
26498       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26499     } catch (std::out_of_range& e) {
26500       {
26501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26502       };
26503     } catch (std::exception& e) {
26504       {
26505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26506       };
26507     } catch (...) {
26508       {
26509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26510       };
26511     }
26512   }
26513   jresult = (void *)result;
26514   return jresult;
26515 }
26516
26517
26518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26519   void * jresult ;
26520   Dali::BaseHandle arg1 ;
26521   Dali::BaseHandle *argp1 ;
26522   Dali::GestureDetector result;
26523
26524   argp1 = (Dali::BaseHandle *)jarg1;
26525   if (!argp1) {
26526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26527     return 0;
26528   }
26529   arg1 = *argp1;
26530   {
26531     try {
26532       result = Dali::GestureDetector::DownCast(arg1);
26533     } catch (std::out_of_range& e) {
26534       {
26535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26536       };
26537     } catch (std::exception& e) {
26538       {
26539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26540       };
26541     } catch (...) {
26542       {
26543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26544       };
26545     }
26546   }
26547   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26548   return jresult;
26549 }
26550
26551
26552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26553   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26554
26555   arg1 = (Dali::GestureDetector *)jarg1;
26556   {
26557     try {
26558       delete arg1;
26559     } catch (std::out_of_range& e) {
26560       {
26561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26562       };
26563     } catch (std::exception& e) {
26564       {
26565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26566       };
26567     } catch (...) {
26568       {
26569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26570       };
26571     }
26572   }
26573 }
26574
26575
26576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26577   void * jresult ;
26578   Dali::GestureDetector *arg1 = 0 ;
26579   Dali::GestureDetector *result = 0 ;
26580
26581   arg1 = (Dali::GestureDetector *)jarg1;
26582   if (!arg1) {
26583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26584     return 0;
26585   }
26586   {
26587     try {
26588       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26589     } catch (std::out_of_range& e) {
26590       {
26591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26592       };
26593     } catch (std::exception& e) {
26594       {
26595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26596       };
26597     } catch (...) {
26598       {
26599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26600       };
26601     }
26602   }
26603   jresult = (void *)result;
26604   return jresult;
26605 }
26606
26607
26608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26609   void * jresult ;
26610   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26611   Dali::GestureDetector *arg2 = 0 ;
26612   Dali::GestureDetector *result = 0 ;
26613
26614   arg1 = (Dali::GestureDetector *)jarg1;
26615   arg2 = (Dali::GestureDetector *)jarg2;
26616   if (!arg2) {
26617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26618     return 0;
26619   }
26620   {
26621     try {
26622       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26623     } catch (std::out_of_range& e) {
26624       {
26625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26626       };
26627     } catch (std::exception& e) {
26628       {
26629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26630       };
26631     } catch (...) {
26632       {
26633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26634       };
26635     }
26636   }
26637   jresult = (void *)result;
26638   return jresult;
26639 }
26640
26641
26642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26643   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26644   Dali::Actor arg2 ;
26645   Dali::Actor *argp2 ;
26646
26647   arg1 = (Dali::GestureDetector *)jarg1;
26648   argp2 = (Dali::Actor *)jarg2;
26649   if (!argp2) {
26650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26651     return ;
26652   }
26653   arg2 = *argp2;
26654   {
26655     try {
26656       (arg1)->Attach(arg2);
26657     } catch (std::out_of_range& e) {
26658       {
26659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26660       };
26661     } catch (std::exception& e) {
26662       {
26663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26664       };
26665     } catch (...) {
26666       {
26667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26668       };
26669     }
26670   }
26671 }
26672
26673
26674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26675   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26676   Dali::Actor arg2 ;
26677   Dali::Actor *argp2 ;
26678
26679   arg1 = (Dali::GestureDetector *)jarg1;
26680   argp2 = (Dali::Actor *)jarg2;
26681   if (!argp2) {
26682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26683     return ;
26684   }
26685   arg2 = *argp2;
26686   {
26687     try {
26688       (arg1)->Detach(arg2);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26700       };
26701     }
26702   }
26703 }
26704
26705
26706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26707   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26708
26709   arg1 = (Dali::GestureDetector *)jarg1;
26710   {
26711     try {
26712       (arg1)->DetachAll();
26713     } catch (std::out_of_range& e) {
26714       {
26715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26716       };
26717     } catch (std::exception& e) {
26718       {
26719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26720       };
26721     } catch (...) {
26722       {
26723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26724       };
26725     }
26726   }
26727 }
26728
26729
26730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26731   unsigned long jresult ;
26732   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26733   size_t result;
26734
26735   arg1 = (Dali::GestureDetector *)jarg1;
26736   {
26737     try {
26738       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26739     } catch (std::out_of_range& e) {
26740       {
26741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26742       };
26743     } catch (std::exception& e) {
26744       {
26745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26746       };
26747     } catch (...) {
26748       {
26749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26750       };
26751     }
26752   }
26753   jresult = (unsigned long)result;
26754   return jresult;
26755 }
26756
26757
26758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26759   void * jresult ;
26760   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26761   size_t arg2 ;
26762   Dali::Actor result;
26763
26764   arg1 = (Dali::GestureDetector *)jarg1;
26765   arg2 = (size_t)jarg2;
26766   {
26767     try {
26768       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26769     } catch (std::out_of_range& e) {
26770       {
26771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26772       };
26773     } catch (std::exception& e) {
26774       {
26775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26776       };
26777     } catch (...) {
26778       {
26779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26780       };
26781     }
26782   }
26783   jresult = new Dali::Actor((const Dali::Actor &)result);
26784   return jresult;
26785 }
26786
26787
26788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26789   void * jresult ;
26790   Dali::Gesture *arg1 = 0 ;
26791   Dali::Gesture *result = 0 ;
26792
26793   arg1 = (Dali::Gesture *)jarg1;
26794   if (!arg1) {
26795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26796     return 0;
26797   }
26798   {
26799     try {
26800       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26801     } catch (std::out_of_range& e) {
26802       {
26803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26804       };
26805     } catch (std::exception& e) {
26806       {
26807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26808       };
26809     } catch (...) {
26810       {
26811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26812       };
26813     }
26814   }
26815   jresult = (void *)result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26821   void * jresult ;
26822   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26823   Dali::Gesture *arg2 = 0 ;
26824   Dali::Gesture *result = 0 ;
26825
26826   arg1 = (Dali::Gesture *)jarg1;
26827   arg2 = (Dali::Gesture *)jarg2;
26828   if (!arg2) {
26829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26830     return 0;
26831   }
26832   {
26833     try {
26834       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26835     } catch (std::out_of_range& e) {
26836       {
26837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (std::exception& e) {
26840       {
26841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849   jresult = (void *)result;
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26855   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26856
26857   arg1 = (Dali::Gesture *)jarg1;
26858   {
26859     try {
26860       delete arg1;
26861     } catch (std::out_of_range& e) {
26862       {
26863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26864       };
26865     } catch (std::exception& e) {
26866       {
26867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26868       };
26869     } catch (...) {
26870       {
26871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26872       };
26873     }
26874   }
26875 }
26876
26877
26878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26879   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26880   Dali::Gesture::Type arg2 ;
26881
26882   arg1 = (Dali::Gesture *)jarg1;
26883   arg2 = (Dali::Gesture::Type)jarg2;
26884   if (arg1) (arg1)->type = arg2;
26885 }
26886
26887
26888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26889   int jresult ;
26890   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26891   Dali::Gesture::Type result;
26892
26893   arg1 = (Dali::Gesture *)jarg1;
26894   result = (Dali::Gesture::Type) ((arg1)->type);
26895   jresult = (int)result;
26896   return jresult;
26897 }
26898
26899
26900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26901   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26902   Dali::Gesture::State arg2 ;
26903
26904   arg1 = (Dali::Gesture *)jarg1;
26905   arg2 = (Dali::Gesture::State)jarg2;
26906   if (arg1) (arg1)->state = arg2;
26907 }
26908
26909
26910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26911   int jresult ;
26912   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26913   Dali::Gesture::State result;
26914
26915   arg1 = (Dali::Gesture *)jarg1;
26916   result = (Dali::Gesture::State) ((arg1)->state);
26917   jresult = (int)result;
26918   return jresult;
26919 }
26920
26921
26922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26923   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26924   unsigned int arg2 ;
26925
26926   arg1 = (Dali::Gesture *)jarg1;
26927   arg2 = (unsigned int)jarg2;
26928   if (arg1) (arg1)->time = arg2;
26929 }
26930
26931
26932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26933   unsigned int jresult ;
26934   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26935   unsigned int result;
26936
26937   arg1 = (Dali::Gesture *)jarg1;
26938   result = (unsigned int) ((arg1)->time);
26939   jresult = result;
26940   return jresult;
26941 }
26942
26943
26944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26945   void * jresult ;
26946   Dali::HoverEvent *result = 0 ;
26947
26948   {
26949     try {
26950       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26951     } catch (std::out_of_range& e) {
26952       {
26953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26954       };
26955     } catch (std::exception& e) {
26956       {
26957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26958       };
26959     } catch (...) {
26960       {
26961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26962       };
26963     }
26964   }
26965   jresult = (void *)result;
26966   return jresult;
26967 }
26968
26969
26970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26971   void * jresult ;
26972   unsigned long arg1 ;
26973   Dali::HoverEvent *result = 0 ;
26974
26975   arg1 = (unsigned long)jarg1;
26976   {
26977     try {
26978       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26979     } catch (std::out_of_range& e) {
26980       {
26981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26982       };
26983     } catch (std::exception& e) {
26984       {
26985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26986       };
26987     } catch (...) {
26988       {
26989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26990       };
26991     }
26992   }
26993   jresult = (void *)result;
26994   return jresult;
26995 }
26996
26997
26998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26999   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27000
27001   arg1 = (Dali::HoverEvent *)jarg1;
27002   {
27003     try {
27004       delete arg1;
27005     } catch (std::out_of_range& e) {
27006       {
27007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27008       };
27009     } catch (std::exception& e) {
27010       {
27011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27012       };
27013     } catch (...) {
27014       {
27015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27016       };
27017     }
27018   }
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27023   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27024   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27025
27026   arg1 = (Dali::HoverEvent *)jarg1;
27027   arg2 = (Dali::TouchPointContainer *)jarg2;
27028   if (arg1) (arg1)->points = *arg2;
27029 }
27030
27031
27032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27033   void * jresult ;
27034   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27035   Dali::TouchPointContainer *result = 0 ;
27036
27037   arg1 = (Dali::HoverEvent *)jarg1;
27038   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27039   jresult = (void *)result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27045   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27046   unsigned long arg2 ;
27047
27048   arg1 = (Dali::HoverEvent *)jarg1;
27049   arg2 = (unsigned long)jarg2;
27050   if (arg1) (arg1)->time = arg2;
27051 }
27052
27053
27054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27055   unsigned long jresult ;
27056   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27057   unsigned long result;
27058
27059   arg1 = (Dali::HoverEvent *)jarg1;
27060   result = (unsigned long) ((arg1)->time);
27061   jresult = (unsigned long)result;
27062   return jresult;
27063 }
27064
27065
27066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27067   unsigned int jresult ;
27068   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27069   unsigned int result;
27070
27071   arg1 = (Dali::HoverEvent *)jarg1;
27072   {
27073     try {
27074       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27075     } catch (std::out_of_range& e) {
27076       {
27077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27078       };
27079     } catch (std::exception& e) {
27080       {
27081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (...) {
27084       {
27085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27086       };
27087     }
27088   }
27089   jresult = result;
27090   return jresult;
27091 }
27092
27093
27094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27095   void * jresult ;
27096   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27097   unsigned int arg2 ;
27098   Dali::TouchPoint *result = 0 ;
27099
27100   arg1 = (Dali::HoverEvent *)jarg1;
27101   arg2 = (unsigned int)jarg2;
27102   {
27103     try {
27104       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27105     } catch (std::out_of_range& e) {
27106       {
27107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27108       };
27109     } catch (std::exception& e) {
27110       {
27111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27112       };
27113     } catch (...) {
27114       {
27115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27116       };
27117     }
27118   }
27119   jresult = (void *)result;
27120   return jresult;
27121 }
27122
27123
27124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27125   void * jresult ;
27126   Dali::KeyEvent *result = 0 ;
27127
27128   {
27129     try {
27130       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27131     } catch (std::out_of_range& e) {
27132       {
27133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27134       };
27135     } catch (std::exception& e) {
27136       {
27137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27138       };
27139     } catch (...) {
27140       {
27141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27142       };
27143     }
27144   }
27145   jresult = (void *)result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27151   void * jresult ;
27152   std::string *arg1 = 0 ;
27153   std::string *arg2 = 0 ;
27154   int arg3 ;
27155   int arg4 ;
27156   unsigned long arg5 ;
27157   Dali::KeyEvent::State *arg6 = 0 ;
27158   Dali::KeyEvent::State temp6 ;
27159   Dali::KeyEvent *result = 0 ;
27160
27161   if (!jarg1) {
27162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27163     return 0;
27164   }
27165   std::string arg1_str(jarg1);
27166   arg1 = &arg1_str;
27167   if (!jarg2) {
27168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27169     return 0;
27170   }
27171   std::string arg2_str(jarg2);
27172   arg2 = &arg2_str;
27173   arg3 = (int)jarg3;
27174   arg4 = (int)jarg4;
27175   arg5 = (unsigned long)jarg5;
27176   temp6 = (Dali::KeyEvent::State)jarg6;
27177   arg6 = &temp6;
27178   {
27179     try {
27180       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (...) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27192       };
27193     }
27194   }
27195   jresult = (void *)result;
27196
27197   //argout typemap for const std::string&
27198
27199
27200   //argout typemap for const std::string&
27201
27202   return jresult;
27203 }
27204
27205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27206   void * jresult ;
27207   Dali::KeyEvent *arg1 = 0 ;
27208   Dali::KeyEvent *result = 0 ;
27209
27210   arg1 = (Dali::KeyEvent *)jarg1;
27211   if (!arg1) {
27212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27213     return 0;
27214   }
27215   {
27216     try {
27217       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27225       };
27226     } catch (...) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27229       };
27230     }
27231   }
27232   jresult = (void *)result;
27233   return jresult;
27234 }
27235
27236
27237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27238   void * jresult ;
27239   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27240   Dali::KeyEvent *arg2 = 0 ;
27241   Dali::KeyEvent *result = 0 ;
27242
27243   arg1 = (Dali::KeyEvent *)jarg1;
27244   arg2 = (Dali::KeyEvent *)jarg2;
27245   if (!arg2) {
27246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27247     return 0;
27248   }
27249   {
27250     try {
27251       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27252     } catch (std::out_of_range& e) {
27253       {
27254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27255       };
27256     } catch (std::exception& e) {
27257       {
27258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27259       };
27260     } catch (...) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27263       };
27264     }
27265   }
27266   jresult = (void *)result;
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27272   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27273
27274   arg1 = (Dali::KeyEvent *)jarg1;
27275   {
27276     try {
27277       delete arg1;
27278     } catch (std::out_of_range& e) {
27279       {
27280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27281       };
27282     } catch (std::exception& e) {
27283       {
27284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27285       };
27286     } catch (...) {
27287       {
27288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27289       };
27290     }
27291   }
27292 }
27293
27294
27295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27296   unsigned int jresult ;
27297   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27298   bool result;
27299
27300   arg1 = (Dali::KeyEvent *)jarg1;
27301   {
27302     try {
27303       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27304     } catch (std::out_of_range& e) {
27305       {
27306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27307       };
27308     } catch (std::exception& e) {
27309       {
27310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27311       };
27312     } catch (...) {
27313       {
27314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27315       };
27316     }
27317   }
27318   jresult = result;
27319   return jresult;
27320 }
27321
27322
27323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27324   unsigned int jresult ;
27325   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27326   bool result;
27327
27328   arg1 = (Dali::KeyEvent *)jarg1;
27329   {
27330     try {
27331       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27332     } catch (std::out_of_range& e) {
27333       {
27334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (std::exception& e) {
27337       {
27338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27343       };
27344     }
27345   }
27346   jresult = result;
27347   return jresult;
27348 }
27349
27350
27351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27352   unsigned int jresult ;
27353   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27354   bool result;
27355
27356   arg1 = (Dali::KeyEvent *)jarg1;
27357   {
27358     try {
27359       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27360     } catch (std::out_of_range& e) {
27361       {
27362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27363       };
27364     } catch (std::exception& e) {
27365       {
27366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (...) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27371       };
27372     }
27373   }
27374   jresult = result;
27375   return jresult;
27376 }
27377
27378
27379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27380   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27381   std::string *arg2 = 0 ;
27382
27383   arg1 = (Dali::KeyEvent *)jarg1;
27384   if (!jarg2) {
27385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27386     return ;
27387   }
27388   std::string arg2_str(jarg2);
27389   arg2 = &arg2_str;
27390   if (arg1) (arg1)->keyPressedName = *arg2;
27391
27392   //argout typemap for const std::string&
27393
27394 }
27395
27396
27397 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27398   char * jresult ;
27399   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27400   std::string *result = 0 ;
27401
27402   arg1 = (Dali::KeyEvent *)jarg1;
27403   result = (std::string *) & ((arg1)->keyPressedName);
27404   jresult = SWIG_csharp_string_callback(result->c_str());
27405   return jresult;
27406 }
27407
27408
27409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27410   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27411   std::string *arg2 = 0 ;
27412
27413   arg1 = (Dali::KeyEvent *)jarg1;
27414   if (!jarg2) {
27415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27416     return ;
27417   }
27418   std::string arg2_str(jarg2);
27419   arg2 = &arg2_str;
27420   if (arg1) (arg1)->keyPressed = *arg2;
27421
27422   //argout typemap for const std::string&
27423
27424 }
27425
27426
27427 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27428   char * jresult ;
27429   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27430   std::string *result = 0 ;
27431
27432   arg1 = (Dali::KeyEvent *)jarg1;
27433   result = (std::string *) & ((arg1)->keyPressed);
27434   jresult = SWIG_csharp_string_callback(result->c_str());
27435   return jresult;
27436 }
27437
27438
27439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27440   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27441   int arg2 ;
27442
27443   arg1 = (Dali::KeyEvent *)jarg1;
27444   arg2 = (int)jarg2;
27445   if (arg1) (arg1)->keyCode = arg2;
27446 }
27447
27448
27449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27450   int jresult ;
27451   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27452   int result;
27453
27454   arg1 = (Dali::KeyEvent *)jarg1;
27455   result = (int) ((arg1)->keyCode);
27456   jresult = result;
27457   return jresult;
27458 }
27459
27460
27461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27462   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27463   int arg2 ;
27464
27465   arg1 = (Dali::KeyEvent *)jarg1;
27466   arg2 = (int)jarg2;
27467   if (arg1) (arg1)->keyModifier = arg2;
27468 }
27469
27470
27471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27472   int jresult ;
27473   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27474   int result;
27475
27476   arg1 = (Dali::KeyEvent *)jarg1;
27477   result = (int) ((arg1)->keyModifier);
27478   jresult = result;
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27484   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27485   unsigned long arg2 ;
27486
27487   arg1 = (Dali::KeyEvent *)jarg1;
27488   arg2 = (unsigned long)jarg2;
27489   if (arg1) (arg1)->time = arg2;
27490 }
27491
27492
27493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27494   unsigned long jresult ;
27495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27496   unsigned long result;
27497
27498   arg1 = (Dali::KeyEvent *)jarg1;
27499   result = (unsigned long) ((arg1)->time);
27500   jresult = (unsigned long)result;
27501   return jresult;
27502 }
27503
27504
27505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   Dali::KeyEvent::State arg2 ;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   arg2 = (Dali::KeyEvent::State)jarg2;
27511   if (arg1) (arg1)->state = arg2;
27512 }
27513
27514
27515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27516   int jresult ;
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   Dali::KeyEvent::State result;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   result = (Dali::KeyEvent::State) ((arg1)->state);
27522   jresult = (int)result;
27523   return jresult;
27524 }
27525
27526
27527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27528   void * jresult ;
27529   Dali::LongPressGestureDetector *result = 0 ;
27530
27531   {
27532     try {
27533       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27541       };
27542     } catch (...) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27545       };
27546     }
27547   }
27548   jresult = (void *)result;
27549   return jresult;
27550 }
27551
27552
27553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27554   void * jresult ;
27555   Dali::LongPressGestureDetector result;
27556
27557   {
27558     try {
27559       result = Dali::LongPressGestureDetector::New();
27560     } catch (std::out_of_range& e) {
27561       {
27562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27563       };
27564     } catch (std::exception& e) {
27565       {
27566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27567       };
27568     } catch (...) {
27569       {
27570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27571       };
27572     }
27573   }
27574   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27575   return jresult;
27576 }
27577
27578
27579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27580   void * jresult ;
27581   unsigned int arg1 ;
27582   Dali::LongPressGestureDetector result;
27583
27584   arg1 = (unsigned int)jarg1;
27585   {
27586     try {
27587       result = Dali::LongPressGestureDetector::New(arg1);
27588     } catch (std::out_of_range& e) {
27589       {
27590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27591       };
27592     } catch (std::exception& e) {
27593       {
27594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27595       };
27596     } catch (...) {
27597       {
27598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27599       };
27600     }
27601   }
27602   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27603   return jresult;
27604 }
27605
27606
27607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27608   void * jresult ;
27609   unsigned int arg1 ;
27610   unsigned int arg2 ;
27611   Dali::LongPressGestureDetector result;
27612
27613   arg1 = (unsigned int)jarg1;
27614   arg2 = (unsigned int)jarg2;
27615   {
27616     try {
27617       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27618     } catch (std::out_of_range& e) {
27619       {
27620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27621       };
27622     } catch (std::exception& e) {
27623       {
27624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27625       };
27626     } catch (...) {
27627       {
27628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27629       };
27630     }
27631   }
27632   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27633   return jresult;
27634 }
27635
27636
27637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27638   void * jresult ;
27639   Dali::BaseHandle arg1 ;
27640   Dali::BaseHandle *argp1 ;
27641   Dali::LongPressGestureDetector result;
27642
27643   argp1 = (Dali::BaseHandle *)jarg1;
27644   if (!argp1) {
27645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27646     return 0;
27647   }
27648   arg1 = *argp1;
27649   {
27650     try {
27651       result = Dali::LongPressGestureDetector::DownCast(arg1);
27652     } catch (std::out_of_range& e) {
27653       {
27654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27655       };
27656     } catch (std::exception& e) {
27657       {
27658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27659       };
27660     } catch (...) {
27661       {
27662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27663       };
27664     }
27665   }
27666   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27667   return jresult;
27668 }
27669
27670
27671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27672   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27673
27674   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27675   {
27676     try {
27677       delete arg1;
27678     } catch (std::out_of_range& e) {
27679       {
27680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27681       };
27682     } catch (std::exception& e) {
27683       {
27684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27685       };
27686     } catch (...) {
27687       {
27688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27689       };
27690     }
27691   }
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27696   void * jresult ;
27697   Dali::LongPressGestureDetector *arg1 = 0 ;
27698   Dali::LongPressGestureDetector *result = 0 ;
27699
27700   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27701   if (!arg1) {
27702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27703     return 0;
27704   }
27705   {
27706     try {
27707       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27708     } catch (std::out_of_range& e) {
27709       {
27710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27711       };
27712     } catch (std::exception& e) {
27713       {
27714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27715       };
27716     } catch (...) {
27717       {
27718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27719       };
27720     }
27721   }
27722   jresult = (void *)result;
27723   return jresult;
27724 }
27725
27726
27727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27728   void * jresult ;
27729   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27730   Dali::LongPressGestureDetector *arg2 = 0 ;
27731   Dali::LongPressGestureDetector *result = 0 ;
27732
27733   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27734   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27735   if (!arg2) {
27736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27737     return 0;
27738   }
27739   {
27740     try {
27741       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27742     } catch (std::out_of_range& e) {
27743       {
27744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27745       };
27746     } catch (std::exception& e) {
27747       {
27748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27749       };
27750     } catch (...) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27753       };
27754     }
27755   }
27756   jresult = (void *)result;
27757   return jresult;
27758 }
27759
27760
27761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27762   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27763   unsigned int arg2 ;
27764
27765   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27766   arg2 = (unsigned int)jarg2;
27767   {
27768     try {
27769       (arg1)->SetTouchesRequired(arg2);
27770     } catch (std::out_of_range& e) {
27771       {
27772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27773       };
27774     } catch (std::exception& e) {
27775       {
27776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27777       };
27778     } catch (...) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27781       };
27782     }
27783   }
27784 }
27785
27786
27787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27788   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27789   unsigned int arg2 ;
27790   unsigned int arg3 ;
27791
27792   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27793   arg2 = (unsigned int)jarg2;
27794   arg3 = (unsigned int)jarg3;
27795   {
27796     try {
27797       (arg1)->SetTouchesRequired(arg2,arg3);
27798     } catch (std::out_of_range& e) {
27799       {
27800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27801       };
27802     } catch (std::exception& e) {
27803       {
27804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27805       };
27806     } catch (...) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27809       };
27810     }
27811   }
27812 }
27813
27814
27815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27816   unsigned int jresult ;
27817   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27818   unsigned int result;
27819
27820   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27821   {
27822     try {
27823       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27824     } catch (std::out_of_range& e) {
27825       {
27826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27827       };
27828     } catch (std::exception& e) {
27829       {
27830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27831       };
27832     } catch (...) {
27833       {
27834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27835       };
27836     }
27837   }
27838   jresult = result;
27839   return jresult;
27840 }
27841
27842
27843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27844   unsigned int jresult ;
27845   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27846   unsigned int result;
27847
27848   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27849   {
27850     try {
27851       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27852     } catch (std::out_of_range& e) {
27853       {
27854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (std::exception& e) {
27857       {
27858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866   jresult = result;
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27872   void * jresult ;
27873   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27874   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27875
27876   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27877   {
27878     try {
27879       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27880     } catch (std::out_of_range& e) {
27881       {
27882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27883       };
27884     } catch (std::exception& e) {
27885       {
27886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27887       };
27888     } catch (...) {
27889       {
27890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27891       };
27892     }
27893   }
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27900   void * jresult ;
27901   Dali::Gesture::State arg1 ;
27902   Dali::LongPressGesture *result = 0 ;
27903
27904   arg1 = (Dali::Gesture::State)jarg1;
27905   {
27906     try {
27907       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27908     } catch (std::out_of_range& e) {
27909       {
27910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (std::exception& e) {
27913       {
27914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27915       };
27916     } catch (...) {
27917       {
27918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27919       };
27920     }
27921   }
27922   jresult = (void *)result;
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27928   void * jresult ;
27929   Dali::LongPressGesture *arg1 = 0 ;
27930   Dali::LongPressGesture *result = 0 ;
27931
27932   arg1 = (Dali::LongPressGesture *)jarg1;
27933   if (!arg1) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27935     return 0;
27936   }
27937   {
27938     try {
27939       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27940     } catch (std::out_of_range& e) {
27941       {
27942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27943       };
27944     } catch (std::exception& e) {
27945       {
27946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27947       };
27948     } catch (...) {
27949       {
27950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27951       };
27952     }
27953   }
27954   jresult = (void *)result;
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27960   void * jresult ;
27961   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27962   Dali::LongPressGesture *arg2 = 0 ;
27963   Dali::LongPressGesture *result = 0 ;
27964
27965   arg1 = (Dali::LongPressGesture *)jarg1;
27966   arg2 = (Dali::LongPressGesture *)jarg2;
27967   if (!arg2) {
27968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27969     return 0;
27970   }
27971   {
27972     try {
27973       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27974     } catch (std::out_of_range& e) {
27975       {
27976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27977       };
27978     } catch (std::exception& e) {
27979       {
27980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (...) {
27983       {
27984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27985       };
27986     }
27987   }
27988   jresult = (void *)result;
27989   return jresult;
27990 }
27991
27992
27993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27994   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27995
27996   arg1 = (Dali::LongPressGesture *)jarg1;
27997   {
27998     try {
27999       delete arg1;
28000     } catch (std::out_of_range& e) {
28001       {
28002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28003       };
28004     } catch (std::exception& e) {
28005       {
28006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28007       };
28008     } catch (...) {
28009       {
28010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28011       };
28012     }
28013   }
28014 }
28015
28016
28017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28018   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28019   unsigned int arg2 ;
28020
28021   arg1 = (Dali::LongPressGesture *)jarg1;
28022   arg2 = (unsigned int)jarg2;
28023   if (arg1) (arg1)->numberOfTouches = arg2;
28024 }
28025
28026
28027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28028   unsigned int jresult ;
28029   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28030   unsigned int result;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   result = (unsigned int) ((arg1)->numberOfTouches);
28034   jresult = result;
28035   return jresult;
28036 }
28037
28038
28039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28040   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28041   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28042
28043   arg1 = (Dali::LongPressGesture *)jarg1;
28044   arg2 = (Dali::Vector2 *)jarg2;
28045   if (arg1) (arg1)->screenPoint = *arg2;
28046 }
28047
28048
28049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28050   void * jresult ;
28051   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28052   Dali::Vector2 *result = 0 ;
28053
28054   arg1 = (Dali::LongPressGesture *)jarg1;
28055   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28056   jresult = (void *)result;
28057   return jresult;
28058 }
28059
28060
28061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28062   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28063   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (Dali::Vector2 *)jarg2;
28067   if (arg1) (arg1)->localPoint = *arg2;
28068 }
28069
28070
28071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28072   void * jresult ;
28073   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28074   Dali::Vector2 *result = 0 ;
28075
28076   arg1 = (Dali::LongPressGesture *)jarg1;
28077   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28078   jresult = (void *)result;
28079   return jresult;
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28084   void * jresult ;
28085   Dali::WheelEvent *result = 0 ;
28086
28087   {
28088     try {
28089       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28090     } catch (std::out_of_range& e) {
28091       {
28092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28093       };
28094     } catch (std::exception& e) {
28095       {
28096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28097       };
28098     } catch (...) {
28099       {
28100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28101       };
28102     }
28103   }
28104   jresult = (void *)result;
28105   return jresult;
28106 }
28107
28108
28109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28110   void * jresult ;
28111   Dali::WheelEvent::Type arg1 ;
28112   int arg2 ;
28113   unsigned int arg3 ;
28114   Dali::Vector2 arg4 ;
28115   int arg5 ;
28116   unsigned int arg6 ;
28117   Dali::Vector2 *argp4 ;
28118   Dali::WheelEvent *result = 0 ;
28119
28120   arg1 = (Dali::WheelEvent::Type)jarg1;
28121   arg2 = (int)jarg2;
28122   arg3 = (unsigned int)jarg3;
28123   argp4 = (Dali::Vector2 *)jarg4;
28124   if (!argp4) {
28125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28126     return 0;
28127   }
28128   arg4 = *argp4;
28129   arg5 = (int)jarg5;
28130   arg6 = (unsigned int)jarg6;
28131   {
28132     try {
28133       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28134     } catch (std::out_of_range& e) {
28135       {
28136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28137       };
28138     } catch (std::exception& e) {
28139       {
28140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28141       };
28142     } catch (...) {
28143       {
28144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28145       };
28146     }
28147   }
28148   jresult = (void *)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28154   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28155
28156   arg1 = (Dali::WheelEvent *)jarg1;
28157   {
28158     try {
28159       delete arg1;
28160     } catch (std::out_of_range& e) {
28161       {
28162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28163       };
28164     } catch (std::exception& e) {
28165       {
28166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28167       };
28168     } catch (...) {
28169       {
28170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28171       };
28172     }
28173   }
28174 }
28175
28176
28177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28178   unsigned int jresult ;
28179   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28180   bool result;
28181
28182   arg1 = (Dali::WheelEvent *)jarg1;
28183   {
28184     try {
28185       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28186     } catch (std::out_of_range& e) {
28187       {
28188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28189       };
28190     } catch (std::exception& e) {
28191       {
28192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28197       };
28198     }
28199   }
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28206   unsigned int jresult ;
28207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28208   bool result;
28209
28210   arg1 = (Dali::WheelEvent *)jarg1;
28211   {
28212     try {
28213       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28214     } catch (std::out_of_range& e) {
28215       {
28216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28217       };
28218     } catch (std::exception& e) {
28219       {
28220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28221       };
28222     } catch (...) {
28223       {
28224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28225       };
28226     }
28227   }
28228   jresult = result;
28229   return jresult;
28230 }
28231
28232
28233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28234   unsigned int jresult ;
28235   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28236   bool result;
28237
28238   arg1 = (Dali::WheelEvent *)jarg1;
28239   {
28240     try {
28241       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28242     } catch (std::out_of_range& e) {
28243       {
28244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28245       };
28246     } catch (std::exception& e) {
28247       {
28248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28253       };
28254     }
28255   }
28256   jresult = result;
28257   return jresult;
28258 }
28259
28260
28261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28262   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28263   Dali::WheelEvent::Type arg2 ;
28264
28265   arg1 = (Dali::WheelEvent *)jarg1;
28266   arg2 = (Dali::WheelEvent::Type)jarg2;
28267   if (arg1) (arg1)->type = arg2;
28268 }
28269
28270
28271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28272   int jresult ;
28273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28274   Dali::WheelEvent::Type result;
28275
28276   arg1 = (Dali::WheelEvent *)jarg1;
28277   result = (Dali::WheelEvent::Type) ((arg1)->type);
28278   jresult = (int)result;
28279   return jresult;
28280 }
28281
28282
28283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28284   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28285   int arg2 ;
28286
28287   arg1 = (Dali::WheelEvent *)jarg1;
28288   arg2 = (int)jarg2;
28289   if (arg1) (arg1)->direction = arg2;
28290 }
28291
28292
28293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28294   int jresult ;
28295   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28296   int result;
28297
28298   arg1 = (Dali::WheelEvent *)jarg1;
28299   result = (int) ((arg1)->direction);
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28307   unsigned int arg2 ;
28308
28309   arg1 = (Dali::WheelEvent *)jarg1;
28310   arg2 = (unsigned int)jarg2;
28311   if (arg1) (arg1)->modifiers = arg2;
28312 }
28313
28314
28315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28316   unsigned int jresult ;
28317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28318   unsigned int result;
28319
28320   arg1 = (Dali::WheelEvent *)jarg1;
28321   result = (unsigned int) ((arg1)->modifiers);
28322   jresult = result;
28323   return jresult;
28324 }
28325
28326
28327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28329   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28330
28331   arg1 = (Dali::WheelEvent *)jarg1;
28332   arg2 = (Dali::Vector2 *)jarg2;
28333   if (arg1) (arg1)->point = *arg2;
28334 }
28335
28336
28337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28338   void * jresult ;
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   Dali::Vector2 *result = 0 ;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   result = (Dali::Vector2 *)& ((arg1)->point);
28344   jresult = (void *)result;
28345   return jresult;
28346 }
28347
28348
28349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   int arg2 ;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   arg2 = (int)jarg2;
28355   if (arg1) (arg1)->z = arg2;
28356 }
28357
28358
28359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28360   int jresult ;
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   int result;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   result = (int) ((arg1)->z);
28366   jresult = result;
28367   return jresult;
28368 }
28369
28370
28371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   unsigned int arg2 ;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   arg2 = (unsigned int)jarg2;
28377   if (arg1) (arg1)->timeStamp = arg2;
28378 }
28379
28380
28381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28382   unsigned int jresult ;
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   unsigned int result;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   result = (unsigned int) ((arg1)->timeStamp);
28388   jresult = result;
28389   return jresult;
28390 }
28391
28392 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28393   char * jresult ;
28394   Dali::KeyEvent *arg1 = 0 ;
28395   std::string result;
28396
28397   arg1 = (Dali::KeyEvent *)jarg1;
28398   if (!arg1) {
28399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28400     return 0;
28401   }
28402   {
28403     try {
28404       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28412       };
28413     } catch (...) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28416       };
28417     }
28418   }
28419   jresult = SWIG_csharp_string_callback((&result)->c_str());
28420   return jresult;
28421 }
28422
28423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28424   int jresult ;
28425   Dali::KeyEvent *arg1 = 0 ;
28426   Dali::DevelDevice::Class::Type result;
28427
28428   arg1 = (Dali::KeyEvent *)jarg1;
28429   if (!arg1) {
28430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28431     return 0;
28432   }
28433   {
28434     try {
28435       result = (Dali::DevelDevice::Class::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (...) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28447       };
28448     }
28449   }
28450   jresult = (int)result;
28451   return jresult;
28452 }
28453
28454
28455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28456   Dali::Actor arg1 ;
28457   Dali::Actor *argp1 ;
28458
28459   argp1 = (Dali::Actor *)jarg1;
28460   if (!argp1) {
28461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28462     return ;
28463   }
28464   arg1 = *argp1;
28465   {
28466     try {
28467       Dali::DevelActor::Raise(arg1);
28468     } catch (std::out_of_range& e) {
28469       {
28470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28471       };
28472     } catch (std::exception& e) {
28473       {
28474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28475       };
28476     } catch (...) {
28477       {
28478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28479       };
28480     }
28481   }
28482 }
28483
28484
28485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28486   Dali::Actor arg1 ;
28487   Dali::Actor *argp1 ;
28488
28489   argp1 = (Dali::Actor *)jarg1;
28490   if (!argp1) {
28491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28492     return ;
28493   }
28494   arg1 = *argp1;
28495   {
28496     try {
28497       Dali::DevelActor::Lower(arg1);
28498     } catch (std::out_of_range& e) {
28499       {
28500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28501       };
28502     } catch (std::exception& e) {
28503       {
28504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28505       };
28506     } catch (...) {
28507       {
28508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28509       };
28510     }
28511   }
28512 }
28513
28514
28515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28516   Dali::Actor arg1 ;
28517   Dali::Actor *argp1 ;
28518
28519   argp1 = (Dali::Actor *)jarg1;
28520   if (!argp1) {
28521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28522     return ;
28523   }
28524   arg1 = *argp1;
28525   {
28526     try {
28527       Dali::DevelActor::RaiseToTop(arg1);
28528     } catch (std::out_of_range& e) {
28529       {
28530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28531       };
28532     } catch (std::exception& e) {
28533       {
28534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28535       };
28536     } catch (...) {
28537       {
28538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28539       };
28540     }
28541   }
28542 }
28543
28544
28545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28546   Dali::Actor arg1 ;
28547   Dali::Actor *argp1 ;
28548
28549   argp1 = (Dali::Actor *)jarg1;
28550   if (!argp1) {
28551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28552     return ;
28553   }
28554   arg1 = *argp1;
28555   {
28556     try {
28557       Dali::DevelActor::LowerToBottom(arg1);
28558     } catch (std::out_of_range& e) {
28559       {
28560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28561       };
28562     } catch (std::exception& e) {
28563       {
28564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28565       };
28566     } catch (...) {
28567       {
28568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28569       };
28570     }
28571   }
28572 }
28573
28574
28575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28576   Dali::Actor arg1 ;
28577   Dali::Actor arg2 ;
28578   Dali::Actor *argp1 ;
28579   Dali::Actor *argp2 ;
28580
28581   argp1 = (Dali::Actor *)jarg1;
28582   if (!argp1) {
28583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28584     return ;
28585   }
28586   arg1 = *argp1;
28587   argp2 = (Dali::Actor *)jarg2;
28588   if (!argp2) {
28589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28590     return ;
28591   }
28592   arg2 = *argp2;
28593   {
28594     try {
28595       Dali::DevelActor::RaiseAbove(arg1,arg2);
28596     } catch (std::out_of_range& e) {
28597       {
28598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28599       };
28600     } catch (std::exception& e) {
28601       {
28602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28603       };
28604     } catch (...) {
28605       {
28606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28607       };
28608     }
28609   }
28610 }
28611
28612
28613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28614   Dali::Actor arg1 ;
28615   Dali::Actor arg2 ;
28616   Dali::Actor *argp1 ;
28617   Dali::Actor *argp2 ;
28618
28619   argp1 = (Dali::Actor *)jarg1;
28620   if (!argp1) {
28621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28622     return ;
28623   }
28624   arg1 = *argp1;
28625   argp2 = (Dali::Actor *)jarg2;
28626   if (!argp2) {
28627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28628     return ;
28629   }
28630   arg2 = *argp2;
28631   {
28632     try {
28633       Dali::DevelActor::LowerBelow(arg1,arg2);
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28641       };
28642     } catch (...) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28645       };
28646     }
28647   }
28648 }
28649
28650
28651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28652   void * jresult ;
28653   Dali::Actor arg1 ;
28654   Dali::Actor *argp1 ;
28655   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28656
28657   argp1 = (Dali::Actor *)jarg1;
28658   if (!argp1) {
28659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28660     return 0;
28661   }
28662   arg1 = *argp1;
28663   {
28664     try {
28665       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28666     } catch (std::out_of_range& e) {
28667       {
28668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28669       };
28670     } catch (std::exception& e) {
28671       {
28672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28673       };
28674     } catch (...) {
28675       {
28676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28677       };
28678     }
28679   }
28680   jresult = (void *)result;
28681   return jresult;
28682 }
28683
28684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28685   int jresult ;
28686   int result;
28687
28688   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28689   jresult = (int)result;
28690   return jresult;
28691 }
28692
28693
28694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28695   int jresult ;
28696   int result;
28697
28698   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28699   jresult = (int)result;
28700   return jresult;
28701 }
28702
28703
28704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28705   int jresult ;
28706   int result;
28707
28708   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28709   jresult = (int)result;
28710   return jresult;
28711 }
28712
28713
28714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28715   int jresult ;
28716   int result;
28717
28718   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28719   jresult = (int)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28725   int jresult ;
28726   int result;
28727
28728   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28729   jresult = (int)result;
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28735   int jresult ;
28736   int result;
28737
28738   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28739   jresult = (int)result;
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28745   int jresult ;
28746   int result;
28747
28748   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28749   jresult = (int)result;
28750   return jresult;
28751 }
28752
28753
28754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28755   int jresult ;
28756   int result;
28757
28758   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28759   jresult = (int)result;
28760   return jresult;
28761 }
28762
28763
28764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28765   int jresult ;
28766   int result;
28767
28768   result = (int)Dali::Actor::Property::SIZE;
28769   jresult = (int)result;
28770   return jresult;
28771 }
28772
28773
28774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28775   int jresult ;
28776   int result;
28777
28778   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28779   jresult = (int)result;
28780   return jresult;
28781 }
28782
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::POSITION;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::POSITION_X;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::POSITION_Y;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::POSITION_Z;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::WORLD_POSITION;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::ORIENTATION;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::SCALE;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::SCALE_X;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::SCALE_Y;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::SCALE_Z;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::WORLD_SCALE;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::VISIBLE;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::COLOR;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::COLOR_RED;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::COLOR_GREEN;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::COLOR_BLUE;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::WORLD_COLOR;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::NAME;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::SENSITIVE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29075   int jresult ;
29076   int result;
29077
29078   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29079   jresult = (int)result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29085   int jresult ;
29086   int result;
29087
29088   result = (int)Dali::Actor::Property::COLOR_MODE;
29089   jresult = (int)result;
29090   return jresult;
29091 }
29092
29093
29094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29095   int jresult ;
29096   int result;
29097
29098   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29099   jresult = (int)result;
29100   return jresult;
29101 }
29102
29103
29104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29105   int jresult ;
29106   int result;
29107
29108   result = (int)Dali::Actor::Property::DRAW_MODE;
29109   jresult = (int)result;
29110   return jresult;
29111 }
29112
29113
29114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29115   int jresult ;
29116   int result;
29117
29118   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29119   jresult = (int)result;
29120   return jresult;
29121 }
29122
29123
29124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29125   int jresult ;
29126   int result;
29127
29128   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29129   jresult = (int)result;
29130   return jresult;
29131 }
29132
29133
29134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29135   int jresult ;
29136   int result;
29137
29138   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29139   jresult = (int)result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29145   int jresult ;
29146   int result;
29147
29148   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29149   jresult = (int)result;
29150   return jresult;
29151 }
29152
29153
29154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29155   int jresult ;
29156   int result;
29157
29158   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29159   jresult = (int)result;
29160   return jresult;
29161 }
29162
29163
29164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29165   int jresult ;
29166   int result;
29167
29168   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29175   int jresult ;
29176   int result;
29177
29178   result = (int)Dali::Actor::Property::PADDING;
29179   jresult = (int)result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29185   int jresult ;
29186   int result;
29187
29188   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29189   jresult = (int)result;
29190   return jresult;
29191 }
29192
29193
29194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29195   int jresult ;
29196   int result;
29197
29198   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29199   jresult = (int)result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29205   int jresult ;
29206   int result;
29207
29208   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29209   jresult = (int)result;
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29215   int jresult ;
29216   int result;
29217
29218   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29219   jresult = (int)result;
29220   return jresult;
29221 }
29222
29223
29224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29225   void * jresult ;
29226   Dali::Actor::Property *result = 0 ;
29227
29228   {
29229     try {
29230       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29231     } catch (std::out_of_range& e) {
29232       {
29233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29234       };
29235     } catch (std::exception& e) {
29236       {
29237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29242       };
29243     }
29244   }
29245   jresult = (void *)result;
29246   return jresult;
29247 }
29248
29249
29250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29251   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29252
29253   arg1 = (Dali::Actor::Property *)jarg1;
29254   {
29255     try {
29256       delete arg1;
29257     } catch (std::out_of_range& e) {
29258       {
29259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29260       };
29261     } catch (std::exception& e) {
29262       {
29263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29264       };
29265     } catch (...) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29268       };
29269     }
29270   }
29271 }
29272
29273
29274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29275   void * jresult ;
29276   Dali::Actor *result = 0 ;
29277
29278   {
29279     try {
29280       result = (Dali::Actor *)new Dali::Actor();
29281     } catch (std::out_of_range& e) {
29282       {
29283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29284       };
29285     } catch (std::exception& e) {
29286       {
29287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29288       };
29289     } catch (...) {
29290       {
29291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29292       };
29293     }
29294   }
29295   jresult = (void *)result;
29296   return jresult;
29297 }
29298
29299
29300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29301   void * jresult ;
29302   Dali::Actor result;
29303
29304   {
29305     try {
29306       result = Dali::Actor::New();
29307     } catch (std::out_of_range& e) {
29308       {
29309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29310       };
29311     } catch (std::exception& e) {
29312       {
29313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29314       };
29315     } catch (...) {
29316       {
29317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29318       };
29319     }
29320   }
29321   jresult = new Dali::Actor((const Dali::Actor &)result);
29322   return jresult;
29323 }
29324
29325
29326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29327   void * jresult ;
29328   Dali::BaseHandle arg1 ;
29329   Dali::BaseHandle *argp1 ;
29330   Dali::Actor result;
29331
29332   argp1 = (Dali::BaseHandle *)jarg1;
29333   if (!argp1) {
29334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29335     return 0;
29336   }
29337   arg1 = *argp1;
29338   {
29339     try {
29340       result = Dali::Actor::DownCast(arg1);
29341     } catch (std::out_of_range& e) {
29342       {
29343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29344       };
29345     } catch (std::exception& e) {
29346       {
29347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29348       };
29349     } catch (...) {
29350       {
29351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29352       };
29353     }
29354   }
29355   jresult = new Dali::Actor((const Dali::Actor &)result);
29356   return jresult;
29357 }
29358
29359
29360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29362
29363   arg1 = (Dali::Actor *)jarg1;
29364   {
29365     try {
29366       delete arg1;
29367     } catch (std::out_of_range& e) {
29368       {
29369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29370       };
29371     } catch (std::exception& e) {
29372       {
29373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29374       };
29375     } catch (...) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29378       };
29379     }
29380   }
29381 }
29382
29383
29384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29385   void * jresult ;
29386   Dali::Actor *arg1 = 0 ;
29387   Dali::Actor *result = 0 ;
29388
29389   arg1 = (Dali::Actor *)jarg1;
29390   if (!arg1) {
29391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29392     return 0;
29393   }
29394   {
29395     try {
29396       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29397     } catch (std::out_of_range& e) {
29398       {
29399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29400       };
29401     } catch (std::exception& e) {
29402       {
29403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29404       };
29405     } catch (...) {
29406       {
29407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29408       };
29409     }
29410   }
29411   jresult = (void *)result;
29412   return jresult;
29413 }
29414
29415
29416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29417   void * jresult ;
29418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29419   Dali::Actor *arg2 = 0 ;
29420   Dali::Actor *result = 0 ;
29421
29422   arg1 = (Dali::Actor *)jarg1;
29423   arg2 = (Dali::Actor *)jarg2;
29424   if (!arg2) {
29425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29426     return 0;
29427   }
29428   {
29429     try {
29430       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29431     } catch (std::out_of_range& e) {
29432       {
29433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (std::exception& e) {
29436       {
29437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29438       };
29439     } catch (...) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29442       };
29443     }
29444   }
29445   jresult = (void *)result;
29446   return jresult;
29447 }
29448
29449
29450 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29451   char * jresult ;
29452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29453   std::string *result = 0 ;
29454
29455   arg1 = (Dali::Actor *)jarg1;
29456   {
29457     try {
29458       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29459     } catch (std::out_of_range& e) {
29460       {
29461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29462       };
29463     } catch (std::exception& e) {
29464       {
29465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29466       };
29467     } catch (...) {
29468       {
29469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29470       };
29471     }
29472   }
29473   jresult = SWIG_csharp_string_callback(result->c_str());
29474   return jresult;
29475 }
29476
29477
29478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29480   std::string *arg2 = 0 ;
29481
29482   arg1 = (Dali::Actor *)jarg1;
29483   if (!jarg2) {
29484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29485     return ;
29486   }
29487   std::string arg2_str(jarg2);
29488   arg2 = &arg2_str;
29489   {
29490     try {
29491       (arg1)->SetName((std::string const &)*arg2);
29492     } catch (std::out_of_range& e) {
29493       {
29494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29495       };
29496     } catch (std::exception& e) {
29497       {
29498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29503       };
29504     }
29505   }
29506
29507   //argout typemap for const std::string&
29508
29509 }
29510
29511
29512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29513   unsigned int jresult ;
29514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29515   unsigned int result;
29516
29517   arg1 = (Dali::Actor *)jarg1;
29518   {
29519     try {
29520       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29521     } catch (std::out_of_range& e) {
29522       {
29523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29524       };
29525     } catch (std::exception& e) {
29526       {
29527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29528       };
29529     } catch (...) {
29530       {
29531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29532       };
29533     }
29534   }
29535   jresult = result;
29536   return jresult;
29537 }
29538
29539
29540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29541   unsigned int jresult ;
29542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29543   bool result;
29544
29545   arg1 = (Dali::Actor *)jarg1;
29546   {
29547     try {
29548       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29549     } catch (std::out_of_range& e) {
29550       {
29551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29552       };
29553     } catch (std::exception& e) {
29554       {
29555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29556       };
29557     } catch (...) {
29558       {
29559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29560       };
29561     }
29562   }
29563   jresult = result;
29564   return jresult;
29565 }
29566
29567
29568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29569   unsigned int jresult ;
29570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29571   bool result;
29572
29573   arg1 = (Dali::Actor *)jarg1;
29574   {
29575     try {
29576       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29577     } catch (std::out_of_range& e) {
29578       {
29579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29580       };
29581     } catch (std::exception& e) {
29582       {
29583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29584       };
29585     } catch (...) {
29586       {
29587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29588       };
29589     }
29590   }
29591   jresult = result;
29592   return jresult;
29593 }
29594
29595
29596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29597   unsigned int jresult ;
29598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29599   bool result;
29600
29601   arg1 = (Dali::Actor *)jarg1;
29602   {
29603     try {
29604       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29605     } catch (std::out_of_range& e) {
29606       {
29607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29608       };
29609     } catch (std::exception& e) {
29610       {
29611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29612       };
29613     } catch (...) {
29614       {
29615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29616       };
29617     }
29618   }
29619   jresult = result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29625   void * jresult ;
29626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29627   Dali::Layer result;
29628
29629   arg1 = (Dali::Actor *)jarg1;
29630   {
29631     try {
29632       result = (arg1)->GetLayer();
29633     } catch (std::out_of_range& e) {
29634       {
29635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (std::exception& e) {
29638       {
29639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (...) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29644       };
29645     }
29646   }
29647   jresult = new Dali::Layer((const Dali::Layer &)result);
29648   return jresult;
29649 }
29650
29651
29652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29654   Dali::Actor arg2 ;
29655   Dali::Actor *argp2 ;
29656
29657   arg1 = (Dali::Actor *)jarg1;
29658   argp2 = (Dali::Actor *)jarg2;
29659   if (!argp2) {
29660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29661     return ;
29662   }
29663   arg2 = *argp2;
29664   {
29665     try {
29666       (arg1)->Add(arg2);
29667     } catch (std::out_of_range& e) {
29668       {
29669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29670       };
29671     } catch (std::exception& e) {
29672       {
29673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29674       };
29675     } catch (...) {
29676       {
29677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29678       };
29679     }
29680   }
29681 }
29682
29683
29684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29686   Dali::Actor arg2 ;
29687   Dali::Actor *argp2 ;
29688
29689   arg1 = (Dali::Actor *)jarg1;
29690   argp2 = (Dali::Actor *)jarg2;
29691   if (!argp2) {
29692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29693     return ;
29694   }
29695   arg2 = *argp2;
29696   {
29697     try {
29698       (arg1)->Remove(arg2);
29699     } catch (std::out_of_range& e) {
29700       {
29701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29702       };
29703     } catch (std::exception& e) {
29704       {
29705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29706       };
29707     } catch (...) {
29708       {
29709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29710       };
29711     }
29712   }
29713 }
29714
29715
29716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29718
29719   arg1 = (Dali::Actor *)jarg1;
29720   {
29721     try {
29722       (arg1)->Unparent();
29723     } catch (std::out_of_range& e) {
29724       {
29725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29726       };
29727     } catch (std::exception& e) {
29728       {
29729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29730       };
29731     } catch (...) {
29732       {
29733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29734       };
29735     }
29736   }
29737 }
29738
29739
29740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29741   unsigned int jresult ;
29742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29743   unsigned int result;
29744
29745   arg1 = (Dali::Actor *)jarg1;
29746   {
29747     try {
29748       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29749     } catch (std::out_of_range& e) {
29750       {
29751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29752       };
29753     } catch (std::exception& e) {
29754       {
29755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29756       };
29757     } catch (...) {
29758       {
29759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29760       };
29761     }
29762   }
29763   jresult = result;
29764   return jresult;
29765 }
29766
29767
29768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29769   void * jresult ;
29770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29771   unsigned int arg2 ;
29772   Dali::Actor result;
29773
29774   arg1 = (Dali::Actor *)jarg1;
29775   arg2 = (unsigned int)jarg2;
29776   {
29777     try {
29778       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29779     } catch (std::out_of_range& e) {
29780       {
29781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29782       };
29783     } catch (std::exception& e) {
29784       {
29785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29786       };
29787     } catch (...) {
29788       {
29789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29790       };
29791     }
29792   }
29793   jresult = new Dali::Actor((const Dali::Actor &)result);
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29799   void * jresult ;
29800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29801   std::string *arg2 = 0 ;
29802   Dali::Actor result;
29803
29804   arg1 = (Dali::Actor *)jarg1;
29805   if (!jarg2) {
29806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29807     return 0;
29808   }
29809   std::string arg2_str(jarg2);
29810   arg2 = &arg2_str;
29811   {
29812     try {
29813       result = (arg1)->FindChildByName((std::string const &)*arg2);
29814     } catch (std::out_of_range& e) {
29815       {
29816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29817       };
29818     } catch (std::exception& e) {
29819       {
29820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29821       };
29822     } catch (...) {
29823       {
29824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29825       };
29826     }
29827   }
29828   jresult = new Dali::Actor((const Dali::Actor &)result);
29829
29830   //argout typemap for const std::string&
29831
29832   return jresult;
29833 }
29834
29835
29836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29837   void * jresult ;
29838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29839   unsigned int arg2 ;
29840   Dali::Actor result;
29841
29842   arg1 = (Dali::Actor *)jarg1;
29843   arg2 = (unsigned int)jarg2;
29844   {
29845     try {
29846       result = (arg1)->FindChildById(arg2);
29847     } catch (std::out_of_range& e) {
29848       {
29849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (std::exception& e) {
29852       {
29853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861   jresult = new Dali::Actor((const Dali::Actor &)result);
29862   return jresult;
29863 }
29864
29865
29866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29867   void * jresult ;
29868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29869   Dali::Actor result;
29870
29871   arg1 = (Dali::Actor *)jarg1;
29872   {
29873     try {
29874       result = ((Dali::Actor const *)arg1)->GetParent();
29875     } catch (std::out_of_range& e) {
29876       {
29877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (std::exception& e) {
29880       {
29881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (...) {
29884       {
29885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29886       };
29887     }
29888   }
29889   jresult = new Dali::Actor((const Dali::Actor &)result);
29890   return jresult;
29891 }
29892
29893
29894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29896   Dali::Vector3 *arg2 = 0 ;
29897
29898   arg1 = (Dali::Actor *)jarg1;
29899   arg2 = (Dali::Vector3 *)jarg2;
29900   if (!arg2) {
29901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29902     return ;
29903   }
29904   {
29905     try {
29906       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29907     } catch (std::out_of_range& e) {
29908       {
29909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29910       };
29911     } catch (std::exception& e) {
29912       {
29913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29914       };
29915     } catch (...) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29918       };
29919     }
29920   }
29921 }
29922
29923
29924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29925   void * jresult ;
29926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29927   Dali::Vector3 result;
29928
29929   arg1 = (Dali::Actor *)jarg1;
29930   {
29931     try {
29932       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29933     } catch (std::out_of_range& e) {
29934       {
29935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29936       };
29937     } catch (std::exception& e) {
29938       {
29939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29940       };
29941     } catch (...) {
29942       {
29943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29944       };
29945     }
29946   }
29947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29948   return jresult;
29949 }
29950
29951
29952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29954   Dali::Vector3 *arg2 = 0 ;
29955
29956   arg1 = (Dali::Actor *)jarg1;
29957   arg2 = (Dali::Vector3 *)jarg2;
29958   if (!arg2) {
29959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29960     return ;
29961   }
29962   {
29963     try {
29964       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29965     } catch (std::out_of_range& e) {
29966       {
29967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29968       };
29969     } catch (std::exception& e) {
29970       {
29971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29976       };
29977     }
29978   }
29979 }
29980
29981
29982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29983   void * jresult ;
29984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29985   Dali::Vector3 result;
29986
29987   arg1 = (Dali::Actor *)jarg1;
29988   {
29989     try {
29990       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29991     } catch (std::out_of_range& e) {
29992       {
29993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29994       };
29995     } catch (std::exception& e) {
29996       {
29997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29998       };
29999     } catch (...) {
30000       {
30001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30002       };
30003     }
30004   }
30005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30012   float arg2 ;
30013   float arg3 ;
30014
30015   arg1 = (Dali::Actor *)jarg1;
30016   arg2 = (float)jarg2;
30017   arg3 = (float)jarg3;
30018   {
30019     try {
30020       (arg1)->SetSize(arg2,arg3);
30021     } catch (std::out_of_range& e) {
30022       {
30023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30024       };
30025     } catch (std::exception& e) {
30026       {
30027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30028       };
30029     } catch (...) {
30030       {
30031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30032       };
30033     }
30034   }
30035 }
30036
30037
30038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30040   float arg2 ;
30041   float arg3 ;
30042   float arg4 ;
30043
30044   arg1 = (Dali::Actor *)jarg1;
30045   arg2 = (float)jarg2;
30046   arg3 = (float)jarg3;
30047   arg4 = (float)jarg4;
30048   {
30049     try {
30050       (arg1)->SetSize(arg2,arg3,arg4);
30051     } catch (std::out_of_range& e) {
30052       {
30053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30054       };
30055     } catch (std::exception& e) {
30056       {
30057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30058       };
30059     } catch (...) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30062       };
30063     }
30064   }
30065 }
30066
30067
30068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30070   Dali::Vector2 *arg2 = 0 ;
30071
30072   arg1 = (Dali::Actor *)jarg1;
30073   arg2 = (Dali::Vector2 *)jarg2;
30074   if (!arg2) {
30075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30076     return ;
30077   }
30078   {
30079     try {
30080       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30081     } catch (std::out_of_range& e) {
30082       {
30083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30084       };
30085     } catch (std::exception& e) {
30086       {
30087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30088       };
30089     } catch (...) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30092       };
30093     }
30094   }
30095 }
30096
30097
30098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30100   Dali::Vector3 *arg2 = 0 ;
30101
30102   arg1 = (Dali::Actor *)jarg1;
30103   arg2 = (Dali::Vector3 *)jarg2;
30104   if (!arg2) {
30105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30106     return ;
30107   }
30108   {
30109     try {
30110       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30111     } catch (std::out_of_range& e) {
30112       {
30113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30114       };
30115     } catch (std::exception& e) {
30116       {
30117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30118       };
30119     } catch (...) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30122       };
30123     }
30124   }
30125 }
30126
30127
30128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30129   void * jresult ;
30130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30131   Dali::Vector3 result;
30132
30133   arg1 = (Dali::Actor *)jarg1;
30134   {
30135     try {
30136       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30137     } catch (std::out_of_range& e) {
30138       {
30139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30140       };
30141     } catch (std::exception& e) {
30142       {
30143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (...) {
30146       {
30147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30148       };
30149     }
30150   }
30151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30152   return jresult;
30153 }
30154
30155
30156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30157   void * jresult ;
30158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30159   Dali::Vector3 result;
30160
30161   arg1 = (Dali::Actor *)jarg1;
30162   {
30163     try {
30164       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30165     } catch (std::out_of_range& e) {
30166       {
30167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30168       };
30169     } catch (std::exception& e) {
30170       {
30171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30172       };
30173     } catch (...) {
30174       {
30175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30176       };
30177     }
30178   }
30179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30180   return jresult;
30181 }
30182
30183
30184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30185   void * jresult ;
30186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30187   Dali::Vector3 result;
30188
30189   arg1 = (Dali::Actor *)jarg1;
30190   {
30191     try {
30192       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30193     } catch (std::out_of_range& e) {
30194       {
30195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30196       };
30197     } catch (std::exception& e) {
30198       {
30199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30200       };
30201     } catch (...) {
30202       {
30203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30204       };
30205     }
30206   }
30207   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30208   return jresult;
30209 }
30210
30211
30212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30214   float arg2 ;
30215   float arg3 ;
30216
30217   arg1 = (Dali::Actor *)jarg1;
30218   arg2 = (float)jarg2;
30219   arg3 = (float)jarg3;
30220   {
30221     try {
30222       (arg1)->SetPosition(arg2,arg3);
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30230       };
30231     } catch (...) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30234       };
30235     }
30236   }
30237 }
30238
30239
30240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30242   float arg2 ;
30243   float arg3 ;
30244   float arg4 ;
30245
30246   arg1 = (Dali::Actor *)jarg1;
30247   arg2 = (float)jarg2;
30248   arg3 = (float)jarg3;
30249   arg4 = (float)jarg4;
30250   {
30251     try {
30252       (arg1)->SetPosition(arg2,arg3,arg4);
30253     } catch (std::out_of_range& e) {
30254       {
30255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30256       };
30257     } catch (std::exception& e) {
30258       {
30259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30260       };
30261     } catch (...) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30264       };
30265     }
30266   }
30267 }
30268
30269
30270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30272   Dali::Vector3 *arg2 = 0 ;
30273
30274   arg1 = (Dali::Actor *)jarg1;
30275   arg2 = (Dali::Vector3 *)jarg2;
30276   if (!arg2) {
30277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30278     return ;
30279   }
30280   {
30281     try {
30282       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30283     } catch (std::out_of_range& e) {
30284       {
30285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30286       };
30287     } catch (std::exception& e) {
30288       {
30289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30290       };
30291     } catch (...) {
30292       {
30293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30294       };
30295     }
30296   }
30297 }
30298
30299
30300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30302   float arg2 ;
30303
30304   arg1 = (Dali::Actor *)jarg1;
30305   arg2 = (float)jarg2;
30306   {
30307     try {
30308       (arg1)->SetX(arg2);
30309     } catch (std::out_of_range& e) {
30310       {
30311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30312       };
30313     } catch (std::exception& e) {
30314       {
30315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30316       };
30317     } catch (...) {
30318       {
30319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30320       };
30321     }
30322   }
30323 }
30324
30325
30326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30328   float arg2 ;
30329
30330   arg1 = (Dali::Actor *)jarg1;
30331   arg2 = (float)jarg2;
30332   {
30333     try {
30334       (arg1)->SetY(arg2);
30335     } catch (std::out_of_range& e) {
30336       {
30337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30338       };
30339     } catch (std::exception& e) {
30340       {
30341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30342       };
30343     } catch (...) {
30344       {
30345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30346       };
30347     }
30348   }
30349 }
30350
30351
30352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30354   float arg2 ;
30355
30356   arg1 = (Dali::Actor *)jarg1;
30357   arg2 = (float)jarg2;
30358   {
30359     try {
30360       (arg1)->SetZ(arg2);
30361     } catch (std::out_of_range& e) {
30362       {
30363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30364       };
30365     } catch (std::exception& e) {
30366       {
30367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30368       };
30369     } catch (...) {
30370       {
30371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30372       };
30373     }
30374   }
30375 }
30376
30377
30378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30380   Dali::Vector3 *arg2 = 0 ;
30381
30382   arg1 = (Dali::Actor *)jarg1;
30383   arg2 = (Dali::Vector3 *)jarg2;
30384   if (!arg2) {
30385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30386     return ;
30387   }
30388   {
30389     try {
30390       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30391     } catch (std::out_of_range& e) {
30392       {
30393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30394       };
30395     } catch (std::exception& e) {
30396       {
30397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30398       };
30399     } catch (...) {
30400       {
30401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30402       };
30403     }
30404   }
30405 }
30406
30407
30408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30409   void * jresult ;
30410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30411   Dali::Vector3 result;
30412
30413   arg1 = (Dali::Actor *)jarg1;
30414   {
30415     try {
30416       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30417     } catch (std::out_of_range& e) {
30418       {
30419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30420       };
30421     } catch (std::exception& e) {
30422       {
30423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30424       };
30425     } catch (...) {
30426       {
30427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30428       };
30429     }
30430   }
30431   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30437   void * jresult ;
30438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30439   Dali::Vector3 result;
30440
30441   arg1 = (Dali::Actor *)jarg1;
30442   {
30443     try {
30444       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30445     } catch (std::out_of_range& e) {
30446       {
30447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30448       };
30449     } catch (std::exception& e) {
30450       {
30451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30452       };
30453     } catch (...) {
30454       {
30455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30456       };
30457     }
30458   }
30459   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30460   return jresult;
30461 }
30462
30463
30464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30466   bool arg2 ;
30467
30468   arg1 = (Dali::Actor *)jarg1;
30469   arg2 = jarg2 ? true : false;
30470   {
30471     try {
30472       (arg1)->SetInheritPosition(arg2);
30473     } catch (std::out_of_range& e) {
30474       {
30475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (std::exception& e) {
30478       {
30479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30480       };
30481     } catch (...) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30484       };
30485     }
30486   }
30487 }
30488
30489
30490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30491   int jresult ;
30492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30493   Dali::PositionInheritanceMode result;
30494
30495   arg1 = (Dali::Actor *)jarg1;
30496   {
30497     try {
30498       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30499     } catch (std::out_of_range& e) {
30500       {
30501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30502       };
30503     } catch (std::exception& e) {
30504       {
30505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30506       };
30507     } catch (...) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30510       };
30511     }
30512   }
30513   jresult = (int)result;
30514   return jresult;
30515 }
30516
30517
30518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30519   unsigned int jresult ;
30520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30521   bool result;
30522
30523   arg1 = (Dali::Actor *)jarg1;
30524   {
30525     try {
30526       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541   jresult = result;
30542   return jresult;
30543 }
30544
30545
30546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30548   Dali::Degree *arg2 = 0 ;
30549   Dali::Vector3 *arg3 = 0 ;
30550
30551   arg1 = (Dali::Actor *)jarg1;
30552   arg2 = (Dali::Degree *)jarg2;
30553   if (!arg2) {
30554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30555     return ;
30556   }
30557   arg3 = (Dali::Vector3 *)jarg3;
30558   if (!arg3) {
30559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30560     return ;
30561   }
30562   {
30563     try {
30564       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30572       };
30573     } catch (...) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30576       };
30577     }
30578   }
30579 }
30580
30581
30582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30584   Dali::Radian *arg2 = 0 ;
30585   Dali::Vector3 *arg3 = 0 ;
30586
30587   arg1 = (Dali::Actor *)jarg1;
30588   arg2 = (Dali::Radian *)jarg2;
30589   if (!arg2) {
30590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30591     return ;
30592   }
30593   arg3 = (Dali::Vector3 *)jarg3;
30594   if (!arg3) {
30595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30596     return ;
30597   }
30598   {
30599     try {
30600       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30601     } catch (std::out_of_range& e) {
30602       {
30603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30604       };
30605     } catch (std::exception& e) {
30606       {
30607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30608       };
30609     } catch (...) {
30610       {
30611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30612       };
30613     }
30614   }
30615 }
30616
30617
30618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30620   Dali::Quaternion *arg2 = 0 ;
30621
30622   arg1 = (Dali::Actor *)jarg1;
30623   arg2 = (Dali::Quaternion *)jarg2;
30624   if (!arg2) {
30625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30626     return ;
30627   }
30628   {
30629     try {
30630       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30631     } catch (std::out_of_range& e) {
30632       {
30633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30634       };
30635     } catch (std::exception& e) {
30636       {
30637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30638       };
30639     } catch (...) {
30640       {
30641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30642       };
30643     }
30644   }
30645 }
30646
30647
30648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30650   Dali::Degree *arg2 = 0 ;
30651   Dali::Vector3 *arg3 = 0 ;
30652
30653   arg1 = (Dali::Actor *)jarg1;
30654   arg2 = (Dali::Degree *)jarg2;
30655   if (!arg2) {
30656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30657     return ;
30658   }
30659   arg3 = (Dali::Vector3 *)jarg3;
30660   if (!arg3) {
30661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30662     return ;
30663   }
30664   {
30665     try {
30666       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30667     } catch (std::out_of_range& e) {
30668       {
30669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30670       };
30671     } catch (std::exception& e) {
30672       {
30673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30674       };
30675     } catch (...) {
30676       {
30677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30678       };
30679     }
30680   }
30681 }
30682
30683
30684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30686   Dali::Radian *arg2 = 0 ;
30687   Dali::Vector3 *arg3 = 0 ;
30688
30689   arg1 = (Dali::Actor *)jarg1;
30690   arg2 = (Dali::Radian *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30693     return ;
30694   }
30695   arg3 = (Dali::Vector3 *)jarg3;
30696   if (!arg3) {
30697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30698     return ;
30699   }
30700   {
30701     try {
30702       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30710       };
30711     } catch (...) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30714       };
30715     }
30716   }
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30722   Dali::Quaternion *arg2 = 0 ;
30723
30724   arg1 = (Dali::Actor *)jarg1;
30725   arg2 = (Dali::Quaternion *)jarg2;
30726   if (!arg2) {
30727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30728     return ;
30729   }
30730   {
30731     try {
30732       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30733     } catch (std::out_of_range& e) {
30734       {
30735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (std::exception& e) {
30738       {
30739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747 }
30748
30749
30750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30751   void * jresult ;
30752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30753   Dali::Quaternion result;
30754
30755   arg1 = (Dali::Actor *)jarg1;
30756   {
30757     try {
30758       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30759     } catch (std::out_of_range& e) {
30760       {
30761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30762       };
30763     } catch (std::exception& e) {
30764       {
30765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30766       };
30767     } catch (...) {
30768       {
30769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30770       };
30771     }
30772   }
30773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30774   return jresult;
30775 }
30776
30777
30778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30780   bool arg2 ;
30781
30782   arg1 = (Dali::Actor *)jarg1;
30783   arg2 = jarg2 ? true : false;
30784   {
30785     try {
30786       (arg1)->SetInheritOrientation(arg2);
30787     } catch (std::out_of_range& e) {
30788       {
30789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30790       };
30791     } catch (std::exception& e) {
30792       {
30793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30794       };
30795     } catch (...) {
30796       {
30797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30798       };
30799     }
30800   }
30801 }
30802
30803
30804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30805   unsigned int jresult ;
30806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30807   bool result;
30808
30809   arg1 = (Dali::Actor *)jarg1;
30810   {
30811     try {
30812       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30813     } catch (std::out_of_range& e) {
30814       {
30815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30816       };
30817     } catch (std::exception& e) {
30818       {
30819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30820       };
30821     } catch (...) {
30822       {
30823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30824       };
30825     }
30826   }
30827   jresult = result;
30828   return jresult;
30829 }
30830
30831
30832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30833   void * jresult ;
30834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30835   Dali::Quaternion result;
30836
30837   arg1 = (Dali::Actor *)jarg1;
30838   {
30839     try {
30840       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30841     } catch (std::out_of_range& e) {
30842       {
30843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30844       };
30845     } catch (std::exception& e) {
30846       {
30847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30848       };
30849     } catch (...) {
30850       {
30851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30852       };
30853     }
30854   }
30855   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30856   return jresult;
30857 }
30858
30859
30860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30862   float arg2 ;
30863
30864   arg1 = (Dali::Actor *)jarg1;
30865   arg2 = (float)jarg2;
30866   {
30867     try {
30868       (arg1)->SetScale(arg2);
30869     } catch (std::out_of_range& e) {
30870       {
30871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30872       };
30873     } catch (std::exception& e) {
30874       {
30875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30876       };
30877     } catch (...) {
30878       {
30879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30880       };
30881     }
30882   }
30883 }
30884
30885
30886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30888   float arg2 ;
30889   float arg3 ;
30890   float arg4 ;
30891
30892   arg1 = (Dali::Actor *)jarg1;
30893   arg2 = (float)jarg2;
30894   arg3 = (float)jarg3;
30895   arg4 = (float)jarg4;
30896   {
30897     try {
30898       (arg1)->SetScale(arg2,arg3,arg4);
30899     } catch (std::out_of_range& e) {
30900       {
30901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30902       };
30903     } catch (std::exception& e) {
30904       {
30905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30906       };
30907     } catch (...) {
30908       {
30909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30910       };
30911     }
30912   }
30913 }
30914
30915
30916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30918   Dali::Vector3 *arg2 = 0 ;
30919
30920   arg1 = (Dali::Actor *)jarg1;
30921   arg2 = (Dali::Vector3 *)jarg2;
30922   if (!arg2) {
30923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30924     return ;
30925   }
30926   {
30927     try {
30928       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30936       };
30937     } catch (...) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30940       };
30941     }
30942   }
30943 }
30944
30945
30946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30948   Dali::Vector3 *arg2 = 0 ;
30949
30950   arg1 = (Dali::Actor *)jarg1;
30951   arg2 = (Dali::Vector3 *)jarg2;
30952   if (!arg2) {
30953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30954     return ;
30955   }
30956   {
30957     try {
30958       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30959     } catch (std::out_of_range& e) {
30960       {
30961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30962       };
30963     } catch (std::exception& e) {
30964       {
30965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30966       };
30967     } catch (...) {
30968       {
30969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30970       };
30971     }
30972   }
30973 }
30974
30975
30976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30977   void * jresult ;
30978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30979   Dali::Vector3 result;
30980
30981   arg1 = (Dali::Actor *)jarg1;
30982   {
30983     try {
30984       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30985     } catch (std::out_of_range& e) {
30986       {
30987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30988       };
30989     } catch (std::exception& e) {
30990       {
30991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30992       };
30993     } catch (...) {
30994       {
30995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30996       };
30997     }
30998   }
30999   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31000   return jresult;
31001 }
31002
31003
31004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31005   void * jresult ;
31006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31007   Dali::Vector3 result;
31008
31009   arg1 = (Dali::Actor *)jarg1;
31010   {
31011     try {
31012       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31013     } catch (std::out_of_range& e) {
31014       {
31015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31016       };
31017     } catch (std::exception& e) {
31018       {
31019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31020       };
31021     } catch (...) {
31022       {
31023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31024       };
31025     }
31026   }
31027   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31028   return jresult;
31029 }
31030
31031
31032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31034   bool arg2 ;
31035
31036   arg1 = (Dali::Actor *)jarg1;
31037   arg2 = jarg2 ? true : false;
31038   {
31039     try {
31040       (arg1)->SetInheritScale(arg2);
31041     } catch (std::out_of_range& e) {
31042       {
31043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31044       };
31045     } catch (std::exception& e) {
31046       {
31047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31048       };
31049     } catch (...) {
31050       {
31051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31052       };
31053     }
31054   }
31055 }
31056
31057
31058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31059   unsigned int jresult ;
31060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31061   bool result;
31062
31063   arg1 = (Dali::Actor *)jarg1;
31064   {
31065     try {
31066       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31067     } catch (std::out_of_range& e) {
31068       {
31069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (std::exception& e) {
31072       {
31073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (...) {
31076       {
31077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31078       };
31079     }
31080   }
31081   jresult = result;
31082   return jresult;
31083 }
31084
31085
31086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31087   void * jresult ;
31088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31089   Dali::Matrix result;
31090
31091   arg1 = (Dali::Actor *)jarg1;
31092   {
31093     try {
31094       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31095     } catch (std::out_of_range& e) {
31096       {
31097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31098       };
31099     } catch (std::exception& e) {
31100       {
31101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31102       };
31103     } catch (...) {
31104       {
31105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31106       };
31107     }
31108   }
31109   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31110   return jresult;
31111 }
31112
31113
31114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31116   bool arg2 ;
31117
31118   arg1 = (Dali::Actor *)jarg1;
31119   arg2 = jarg2 ? true : false;
31120   {
31121     try {
31122       (arg1)->SetVisible(arg2);
31123     } catch (std::out_of_range& e) {
31124       {
31125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31126       };
31127     } catch (std::exception& e) {
31128       {
31129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31130       };
31131     } catch (...) {
31132       {
31133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31134       };
31135     }
31136   }
31137 }
31138
31139
31140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31141   unsigned int jresult ;
31142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31143   bool result;
31144
31145   arg1 = (Dali::Actor *)jarg1;
31146   {
31147     try {
31148       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31149     } catch (std::out_of_range& e) {
31150       {
31151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31152       };
31153     } catch (std::exception& e) {
31154       {
31155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31156       };
31157     } catch (...) {
31158       {
31159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31160       };
31161     }
31162   }
31163   jresult = result;
31164   return jresult;
31165 }
31166
31167
31168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31170   float arg2 ;
31171
31172   arg1 = (Dali::Actor *)jarg1;
31173   arg2 = (float)jarg2;
31174   {
31175     try {
31176       (arg1)->SetOpacity(arg2);
31177     } catch (std::out_of_range& e) {
31178       {
31179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31180       };
31181     } catch (std::exception& e) {
31182       {
31183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31188       };
31189     }
31190   }
31191 }
31192
31193
31194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31195   float jresult ;
31196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31197   float result;
31198
31199   arg1 = (Dali::Actor *)jarg1;
31200   {
31201     try {
31202       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31203     } catch (std::out_of_range& e) {
31204       {
31205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31206       };
31207     } catch (std::exception& e) {
31208       {
31209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (...) {
31212       {
31213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31214       };
31215     }
31216   }
31217   jresult = result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31224   Dali::Vector4 *arg2 = 0 ;
31225
31226   arg1 = (Dali::Actor *)jarg1;
31227   arg2 = (Dali::Vector4 *)jarg2;
31228   if (!arg2) {
31229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31230     return ;
31231   }
31232   {
31233     try {
31234       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31246       };
31247     }
31248   }
31249 }
31250
31251
31252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31253   void * jresult ;
31254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31255   Dali::Vector4 result;
31256
31257   arg1 = (Dali::Actor *)jarg1;
31258   {
31259     try {
31260       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31261     } catch (std::out_of_range& e) {
31262       {
31263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31264       };
31265     } catch (std::exception& e) {
31266       {
31267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31268       };
31269     } catch (...) {
31270       {
31271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31272       };
31273     }
31274   }
31275   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31276   return jresult;
31277 }
31278
31279
31280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31282   Dali::ColorMode arg2 ;
31283
31284   arg1 = (Dali::Actor *)jarg1;
31285   arg2 = (Dali::ColorMode)jarg2;
31286   {
31287     try {
31288       (arg1)->SetColorMode(arg2);
31289     } catch (std::out_of_range& e) {
31290       {
31291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31292       };
31293     } catch (std::exception& e) {
31294       {
31295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31296       };
31297     } catch (...) {
31298       {
31299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31300       };
31301     }
31302   }
31303 }
31304
31305
31306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31307   int jresult ;
31308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31309   Dali::ColorMode result;
31310
31311   arg1 = (Dali::Actor *)jarg1;
31312   {
31313     try {
31314       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31315     } catch (std::out_of_range& e) {
31316       {
31317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31318       };
31319     } catch (std::exception& e) {
31320       {
31321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31322       };
31323     } catch (...) {
31324       {
31325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31326       };
31327     }
31328   }
31329   jresult = (int)result;
31330   return jresult;
31331 }
31332
31333
31334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31335   void * jresult ;
31336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31337   Dali::Vector4 result;
31338
31339   arg1 = (Dali::Actor *)jarg1;
31340   {
31341     try {
31342       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31343     } catch (std::out_of_range& e) {
31344       {
31345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31346       };
31347     } catch (std::exception& e) {
31348       {
31349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31350       };
31351     } catch (...) {
31352       {
31353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31354       };
31355     }
31356   }
31357   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31358   return jresult;
31359 }
31360
31361
31362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31364   Dali::DrawMode::Type arg2 ;
31365
31366   arg1 = (Dali::Actor *)jarg1;
31367   arg2 = (Dali::DrawMode::Type)jarg2;
31368   {
31369     try {
31370       (arg1)->SetDrawMode(arg2);
31371     } catch (std::out_of_range& e) {
31372       {
31373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31374       };
31375     } catch (std::exception& e) {
31376       {
31377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31378       };
31379     } catch (...) {
31380       {
31381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31382       };
31383     }
31384   }
31385 }
31386
31387
31388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31389   int jresult ;
31390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31391   Dali::DrawMode::Type result;
31392
31393   arg1 = (Dali::Actor *)jarg1;
31394   {
31395     try {
31396       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31397     } catch (std::out_of_range& e) {
31398       {
31399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31400       };
31401     } catch (std::exception& e) {
31402       {
31403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31404       };
31405     } catch (...) {
31406       {
31407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31408       };
31409     }
31410   }
31411   jresult = (int)result;
31412   return jresult;
31413 }
31414
31415
31416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31418   bool arg2 ;
31419
31420   arg1 = (Dali::Actor *)jarg1;
31421   arg2 = jarg2 ? true : false;
31422   {
31423     try {
31424       (arg1)->SetSensitive(arg2);
31425     } catch (std::out_of_range& e) {
31426       {
31427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31428       };
31429     } catch (std::exception& e) {
31430       {
31431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31432       };
31433     } catch (...) {
31434       {
31435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31436       };
31437     }
31438   }
31439 }
31440
31441
31442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31443   unsigned int jresult ;
31444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31445   bool result;
31446
31447   arg1 = (Dali::Actor *)jarg1;
31448   {
31449     try {
31450       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31451     } catch (std::out_of_range& e) {
31452       {
31453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31454       };
31455     } catch (std::exception& e) {
31456       {
31457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31458       };
31459     } catch (...) {
31460       {
31461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31462       };
31463     }
31464   }
31465   jresult = result;
31466   return jresult;
31467 }
31468
31469
31470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31471   unsigned int jresult ;
31472   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31473   float *arg2 = 0 ;
31474   float *arg3 = 0 ;
31475   float arg4 ;
31476   float arg5 ;
31477   bool result;
31478
31479   arg1 = (Dali::Actor *)jarg1;
31480   arg2 = (float *)jarg2;
31481   arg3 = (float *)jarg3;
31482   arg4 = (float)jarg4;
31483   arg5 = (float)jarg5;
31484   {
31485     try {
31486       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31487     } catch (std::out_of_range& e) {
31488       {
31489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31490       };
31491     } catch (std::exception& e) {
31492       {
31493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31494       };
31495     } catch (...) {
31496       {
31497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31498       };
31499     }
31500   }
31501   jresult = result;
31502   return jresult;
31503 }
31504
31505
31506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31508   bool arg2 ;
31509
31510   arg1 = (Dali::Actor *)jarg1;
31511   arg2 = jarg2 ? true : false;
31512   {
31513     try {
31514       (arg1)->SetLeaveRequired(arg2);
31515     } catch (std::out_of_range& e) {
31516       {
31517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31518       };
31519     } catch (std::exception& e) {
31520       {
31521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31522       };
31523     } catch (...) {
31524       {
31525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31526       };
31527     }
31528   }
31529 }
31530
31531
31532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31533   unsigned int jresult ;
31534   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31535   bool result;
31536
31537   arg1 = (Dali::Actor *)jarg1;
31538   {
31539     try {
31540       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31541     } catch (std::out_of_range& e) {
31542       {
31543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31544       };
31545     } catch (std::exception& e) {
31546       {
31547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31548       };
31549     } catch (...) {
31550       {
31551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31552       };
31553     }
31554   }
31555   jresult = result;
31556   return jresult;
31557 }
31558
31559
31560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31562   bool arg2 ;
31563
31564   arg1 = (Dali::Actor *)jarg1;
31565   arg2 = jarg2 ? true : false;
31566   {
31567     try {
31568       (arg1)->SetKeyboardFocusable(arg2);
31569     } catch (std::out_of_range& e) {
31570       {
31571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31572       };
31573     } catch (std::exception& e) {
31574       {
31575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31576       };
31577     } catch (...) {
31578       {
31579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31580       };
31581     }
31582   }
31583 }
31584
31585
31586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31587   unsigned int jresult ;
31588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31589   bool result;
31590
31591   arg1 = (Dali::Actor *)jarg1;
31592   {
31593     try {
31594       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31595     } catch (std::out_of_range& e) {
31596       {
31597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31598       };
31599     } catch (std::exception& e) {
31600       {
31601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31602       };
31603     } catch (...) {
31604       {
31605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31606       };
31607     }
31608   }
31609   jresult = result;
31610   return jresult;
31611 }
31612
31613
31614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31616   Dali::ResizePolicy::Type arg2 ;
31617   Dali::Dimension::Type arg3 ;
31618
31619   arg1 = (Dali::Actor *)jarg1;
31620   arg2 = (Dali::ResizePolicy::Type)jarg2;
31621   arg3 = (Dali::Dimension::Type)jarg3;
31622   {
31623     try {
31624       (arg1)->SetResizePolicy(arg2,arg3);
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31632       };
31633     } catch (...) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31636       };
31637     }
31638   }
31639 }
31640
31641
31642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31643   int jresult ;
31644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31645   Dali::Dimension::Type arg2 ;
31646   Dali::ResizePolicy::Type result;
31647
31648   arg1 = (Dali::Actor *)jarg1;
31649   arg2 = (Dali::Dimension::Type)jarg2;
31650   {
31651     try {
31652       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31653     } catch (std::out_of_range& e) {
31654       {
31655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (std::exception& e) {
31658       {
31659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31664       };
31665     }
31666   }
31667   jresult = (int)result;
31668   return jresult;
31669 }
31670
31671
31672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31674   Dali::SizeScalePolicy::Type arg2 ;
31675
31676   arg1 = (Dali::Actor *)jarg1;
31677   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31678   {
31679     try {
31680       (arg1)->SetSizeScalePolicy(arg2);
31681     } catch (std::out_of_range& e) {
31682       {
31683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31684       };
31685     } catch (std::exception& e) {
31686       {
31687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31688       };
31689     } catch (...) {
31690       {
31691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31692       };
31693     }
31694   }
31695 }
31696
31697
31698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31699   int jresult ;
31700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31701   Dali::SizeScalePolicy::Type result;
31702
31703   arg1 = (Dali::Actor *)jarg1;
31704   {
31705     try {
31706       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31707     } catch (std::out_of_range& e) {
31708       {
31709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31710       };
31711     } catch (std::exception& e) {
31712       {
31713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31714       };
31715     } catch (...) {
31716       {
31717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31718       };
31719     }
31720   }
31721   jresult = (int)result;
31722   return jresult;
31723 }
31724
31725
31726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31728   Dali::Vector3 *arg2 = 0 ;
31729
31730   arg1 = (Dali::Actor *)jarg1;
31731   arg2 = (Dali::Vector3 *)jarg2;
31732   if (!arg2) {
31733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31734     return ;
31735   }
31736   {
31737     try {
31738       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31746       };
31747     } catch (...) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31750       };
31751     }
31752   }
31753 }
31754
31755
31756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31757   void * jresult ;
31758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31759   Dali::Vector3 result;
31760
31761   arg1 = (Dali::Actor *)jarg1;
31762   {
31763     try {
31764       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31765     } catch (std::out_of_range& e) {
31766       {
31767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31768       };
31769     } catch (std::exception& e) {
31770       {
31771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31772       };
31773     } catch (...) {
31774       {
31775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31776       };
31777     }
31778   }
31779   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31780   return jresult;
31781 }
31782
31783
31784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31785   float jresult ;
31786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31787   float arg2 ;
31788   float result;
31789
31790   arg1 = (Dali::Actor *)jarg1;
31791   arg2 = (float)jarg2;
31792   {
31793     try {
31794       result = (float)(arg1)->GetHeightForWidth(arg2);
31795     } catch (std::out_of_range& e) {
31796       {
31797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31798       };
31799     } catch (std::exception& e) {
31800       {
31801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (...) {
31804       {
31805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31806       };
31807     }
31808   }
31809   jresult = result;
31810   return jresult;
31811 }
31812
31813
31814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31815   float jresult ;
31816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31817   float arg2 ;
31818   float result;
31819
31820   arg1 = (Dali::Actor *)jarg1;
31821   arg2 = (float)jarg2;
31822   {
31823     try {
31824       result = (float)(arg1)->GetWidthForHeight(arg2);
31825     } catch (std::out_of_range& e) {
31826       {
31827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31828       };
31829     } catch (std::exception& e) {
31830       {
31831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31832       };
31833     } catch (...) {
31834       {
31835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31836       };
31837     }
31838   }
31839   jresult = result;
31840   return jresult;
31841 }
31842
31843
31844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31845   float jresult ;
31846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31847   Dali::Dimension::Type arg2 ;
31848   float result;
31849
31850   arg1 = (Dali::Actor *)jarg1;
31851   arg2 = (Dali::Dimension::Type)jarg2;
31852   {
31853     try {
31854       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31855     } catch (std::out_of_range& e) {
31856       {
31857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31858       };
31859     } catch (std::exception& e) {
31860       {
31861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31862       };
31863     } catch (...) {
31864       {
31865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31866       };
31867     }
31868   }
31869   jresult = result;
31870   return jresult;
31871 }
31872
31873
31874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31876   Dali::Padding *arg2 = 0 ;
31877
31878   arg1 = (Dali::Actor *)jarg1;
31879   arg2 = (Dali::Padding *)jarg2;
31880   if (!arg2) {
31881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31882     return ;
31883   }
31884   {
31885     try {
31886       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31887     } catch (std::out_of_range& e) {
31888       {
31889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31890       };
31891     } catch (std::exception& e) {
31892       {
31893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31894       };
31895     } catch (...) {
31896       {
31897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31898       };
31899     }
31900   }
31901 }
31902
31903
31904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31906   Dali::Padding *arg2 = 0 ;
31907
31908   arg1 = (Dali::Actor *)jarg1;
31909   arg2 = (Dali::Padding *)jarg2;
31910   if (!arg2) {
31911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31912     return ;
31913   }
31914   {
31915     try {
31916       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31917     } catch (std::out_of_range& e) {
31918       {
31919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31920       };
31921     } catch (std::exception& e) {
31922       {
31923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31924       };
31925     } catch (...) {
31926       {
31927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31928       };
31929     }
31930   }
31931 }
31932
31933
31934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31936   Dali::Vector2 *arg2 = 0 ;
31937
31938   arg1 = (Dali::Actor *)jarg1;
31939   arg2 = (Dali::Vector2 *)jarg2;
31940   if (!arg2) {
31941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31942     return ;
31943   }
31944   {
31945     try {
31946       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31947     } catch (std::out_of_range& e) {
31948       {
31949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31950       };
31951     } catch (std::exception& e) {
31952       {
31953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31954       };
31955     } catch (...) {
31956       {
31957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31958       };
31959     }
31960   }
31961 }
31962
31963
31964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31965   void * jresult ;
31966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31967   Dali::Vector2 result;
31968
31969   arg1 = (Dali::Actor *)jarg1;
31970   {
31971     try {
31972       result = (arg1)->GetMinimumSize();
31973     } catch (std::out_of_range& e) {
31974       {
31975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31976       };
31977     } catch (std::exception& e) {
31978       {
31979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (...) {
31982       {
31983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31984       };
31985     }
31986   }
31987   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31988   return jresult;
31989 }
31990
31991
31992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31994   Dali::Vector2 *arg2 = 0 ;
31995
31996   arg1 = (Dali::Actor *)jarg1;
31997   arg2 = (Dali::Vector2 *)jarg2;
31998   if (!arg2) {
31999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32000     return ;
32001   }
32002   {
32003     try {
32004       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32005     } catch (std::out_of_range& e) {
32006       {
32007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32008       };
32009     } catch (std::exception& e) {
32010       {
32011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (...) {
32014       {
32015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32016       };
32017     }
32018   }
32019 }
32020
32021
32022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32023   void * jresult ;
32024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32025   Dali::Vector2 result;
32026
32027   arg1 = (Dali::Actor *)jarg1;
32028   {
32029     try {
32030       result = (arg1)->GetMaximumSize();
32031     } catch (std::out_of_range& e) {
32032       {
32033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32034       };
32035     } catch (std::exception& e) {
32036       {
32037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32038       };
32039     } catch (...) {
32040       {
32041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32042       };
32043     }
32044   }
32045   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32046   return jresult;
32047 }
32048
32049
32050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32051   int jresult ;
32052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32053   int result;
32054
32055   arg1 = (Dali::Actor *)jarg1;
32056   {
32057     try {
32058       result = (int)(arg1)->GetHierarchyDepth();
32059     } catch (std::out_of_range& e) {
32060       {
32061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32062       };
32063     } catch (std::exception& e) {
32064       {
32065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32066       };
32067     } catch (...) {
32068       {
32069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32070       };
32071     }
32072   }
32073   jresult = result;
32074   return jresult;
32075 }
32076
32077
32078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32079   unsigned int jresult ;
32080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32081   Dali::Renderer *arg2 = 0 ;
32082   unsigned int result;
32083
32084   arg1 = (Dali::Actor *)jarg1;
32085   arg2 = (Dali::Renderer *)jarg2;
32086   if (!arg2) {
32087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32088     return 0;
32089   }
32090   {
32091     try {
32092       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32093     } catch (std::out_of_range& e) {
32094       {
32095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32096       };
32097     } catch (std::exception& e) {
32098       {
32099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32100       };
32101     } catch (...) {
32102       {
32103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32104       };
32105     }
32106   }
32107   jresult = result;
32108   return jresult;
32109 }
32110
32111
32112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32113   unsigned int jresult ;
32114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32115   unsigned int result;
32116
32117   arg1 = (Dali::Actor *)jarg1;
32118   {
32119     try {
32120       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32121     } catch (std::out_of_range& e) {
32122       {
32123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32124       };
32125     } catch (std::exception& e) {
32126       {
32127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32128       };
32129     } catch (...) {
32130       {
32131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32132       };
32133     }
32134   }
32135   jresult = result;
32136   return jresult;
32137 }
32138
32139
32140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32141   void * jresult ;
32142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32143   unsigned int arg2 ;
32144   Dali::Renderer result;
32145
32146   arg1 = (Dali::Actor *)jarg1;
32147   arg2 = (unsigned int)jarg2;
32148   {
32149     try {
32150       result = (arg1)->GetRendererAt(arg2);
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (...) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32162       };
32163     }
32164   }
32165   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32166   return jresult;
32167 }
32168
32169
32170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32172   Dali::Renderer *arg2 = 0 ;
32173
32174   arg1 = (Dali::Actor *)jarg1;
32175   arg2 = (Dali::Renderer *)jarg2;
32176   if (!arg2) {
32177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32178     return ;
32179   }
32180   {
32181     try {
32182       (arg1)->RemoveRenderer(*arg2);
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (...) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32194       };
32195     }
32196   }
32197 }
32198
32199
32200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32202   unsigned int arg2 ;
32203
32204   arg1 = (Dali::Actor *)jarg1;
32205   arg2 = (unsigned int)jarg2;
32206   {
32207     try {
32208       (arg1)->RemoveRenderer(arg2);
32209     } catch (std::out_of_range& e) {
32210       {
32211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32212       };
32213     } catch (std::exception& e) {
32214       {
32215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32216       };
32217     } catch (...) {
32218       {
32219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32220       };
32221     }
32222   }
32223 }
32224
32225
32226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32227   void * jresult ;
32228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32229   Dali::Actor::TouchSignalType *result = 0 ;
32230
32231   arg1 = (Dali::Actor *)jarg1;
32232   {
32233     try {
32234       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32235     } catch (std::out_of_range& e) {
32236       {
32237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32238       };
32239     } catch (std::exception& e) {
32240       {
32241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32242       };
32243     } catch (...) {
32244       {
32245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32246       };
32247     }
32248   }
32249   jresult = (void *)result;
32250   return jresult;
32251 }
32252
32253
32254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32255   void * jresult ;
32256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32257   Dali::Actor::TouchDataSignalType *result = 0 ;
32258
32259   arg1 = (Dali::Actor *)jarg1;
32260   {
32261     try {
32262       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32263     } catch (std::out_of_range& e) {
32264       {
32265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32266       };
32267     } catch (std::exception& e) {
32268       {
32269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32270       };
32271     } catch (...) {
32272       {
32273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32274       };
32275     }
32276   }
32277   jresult = (void *)result;
32278   return jresult;
32279 }
32280
32281
32282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32283   void * jresult ;
32284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32285   Dali::Actor::HoverSignalType *result = 0 ;
32286
32287   arg1 = (Dali::Actor *)jarg1;
32288   {
32289     try {
32290       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32291     } catch (std::out_of_range& e) {
32292       {
32293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32294       };
32295     } catch (std::exception& e) {
32296       {
32297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32298       };
32299     } catch (...) {
32300       {
32301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32302       };
32303     }
32304   }
32305   jresult = (void *)result;
32306   return jresult;
32307 }
32308
32309
32310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32311   void * jresult ;
32312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32313   Dali::Actor::WheelEventSignalType *result = 0 ;
32314
32315   arg1 = (Dali::Actor *)jarg1;
32316   {
32317     try {
32318       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32319     } catch (std::out_of_range& e) {
32320       {
32321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (std::exception& e) {
32324       {
32325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32326       };
32327     } catch (...) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32330       };
32331     }
32332   }
32333   jresult = (void *)result;
32334   return jresult;
32335 }
32336
32337
32338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32339   void * jresult ;
32340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32341   Dali::Actor::OnStageSignalType *result = 0 ;
32342
32343   arg1 = (Dali::Actor *)jarg1;
32344   {
32345     try {
32346       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32347     } catch (std::out_of_range& e) {
32348       {
32349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32350       };
32351     } catch (std::exception& e) {
32352       {
32353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32354       };
32355     } catch (...) {
32356       {
32357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32358       };
32359     }
32360   }
32361   jresult = (void *)result;
32362   return jresult;
32363 }
32364
32365
32366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32367   void * jresult ;
32368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32369   Dali::Actor::OffStageSignalType *result = 0 ;
32370
32371   arg1 = (Dali::Actor *)jarg1;
32372   {
32373     try {
32374       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32375     } catch (std::out_of_range& e) {
32376       {
32377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (std::exception& e) {
32380       {
32381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389   jresult = (void *)result;
32390   return jresult;
32391 }
32392
32393
32394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32395   void * jresult ;
32396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32397   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32398
32399   arg1 = (Dali::Actor *)jarg1;
32400   {
32401     try {
32402       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32403     } catch (std::out_of_range& e) {
32404       {
32405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32406       };
32407     } catch (std::exception& e) {
32408       {
32409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32410       };
32411     } catch (...) {
32412       {
32413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32414       };
32415     }
32416   }
32417   jresult = (void *)result;
32418   return jresult;
32419 }
32420
32421
32422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32423   Dali::Actor *arg1 = 0 ;
32424
32425   arg1 = (Dali::Actor *)jarg1;
32426   if (!arg1) {
32427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32428     return ;
32429   }
32430   {
32431     try {
32432       Dali::UnparentAndReset(*arg1);
32433     } catch (std::out_of_range& e) {
32434       {
32435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32436       };
32437     } catch (std::exception& e) {
32438       {
32439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32440       };
32441     } catch (...) {
32442       {
32443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32444       };
32445     }
32446   }
32447 }
32448
32449
32450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32451   int jresult ;
32452   int result;
32453
32454   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32455   jresult = (int)result;
32456   return jresult;
32457 }
32458
32459
32460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32461   int jresult ;
32462   int result;
32463
32464   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32465   jresult = (int)result;
32466   return jresult;
32467 }
32468
32469
32470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32471   int jresult ;
32472   int result;
32473
32474   result = (int)Dali::Layer::Property::BEHAVIOR;
32475   jresult = (int)result;
32476   return jresult;
32477 }
32478
32479
32480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32481   void * jresult ;
32482   Dali::Layer::Property *result = 0 ;
32483
32484   {
32485     try {
32486       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32487     } catch (std::out_of_range& e) {
32488       {
32489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (std::exception& e) {
32492       {
32493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32494       };
32495     } catch (...) {
32496       {
32497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32498       };
32499     }
32500   }
32501   jresult = (void *)result;
32502   return jresult;
32503 }
32504
32505
32506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32507   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32508
32509   arg1 = (Dali::Layer::Property *)jarg1;
32510   {
32511     try {
32512       delete arg1;
32513     } catch (std::out_of_range& e) {
32514       {
32515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32516       };
32517     } catch (std::exception& e) {
32518       {
32519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32524       };
32525     }
32526   }
32527 }
32528
32529
32530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32531   void * jresult ;
32532   Dali::Layer *result = 0 ;
32533
32534   {
32535     try {
32536       result = (Dali::Layer *)new Dali::Layer();
32537     } catch (std::out_of_range& e) {
32538       {
32539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32540       };
32541     } catch (std::exception& e) {
32542       {
32543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32544       };
32545     } catch (...) {
32546       {
32547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32548       };
32549     }
32550   }
32551   jresult = (void *)result;
32552   return jresult;
32553 }
32554
32555
32556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32557   void * jresult ;
32558   Dali::Layer result;
32559
32560   {
32561     try {
32562       result = Dali::Layer::New();
32563     } catch (std::out_of_range& e) {
32564       {
32565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32566       };
32567     } catch (std::exception& e) {
32568       {
32569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32570       };
32571     } catch (...) {
32572       {
32573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32574       };
32575     }
32576   }
32577   jresult = new Dali::Layer((const Dali::Layer &)result);
32578   return jresult;
32579 }
32580
32581
32582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32583   void * jresult ;
32584   Dali::BaseHandle arg1 ;
32585   Dali::BaseHandle *argp1 ;
32586   Dali::Layer result;
32587
32588   argp1 = (Dali::BaseHandle *)jarg1;
32589   if (!argp1) {
32590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32591     return 0;
32592   }
32593   arg1 = *argp1;
32594   {
32595     try {
32596       result = Dali::Layer::DownCast(arg1);
32597     } catch (std::out_of_range& e) {
32598       {
32599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32600       };
32601     } catch (std::exception& e) {
32602       {
32603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32604       };
32605     } catch (...) {
32606       {
32607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32608       };
32609     }
32610   }
32611   jresult = new Dali::Layer((const Dali::Layer &)result);
32612   return jresult;
32613 }
32614
32615
32616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32617   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32618
32619   arg1 = (Dali::Layer *)jarg1;
32620   {
32621     try {
32622       delete arg1;
32623     } catch (std::out_of_range& e) {
32624       {
32625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32626       };
32627     } catch (std::exception& e) {
32628       {
32629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (...) {
32632       {
32633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32634       };
32635     }
32636   }
32637 }
32638
32639
32640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32641   void * jresult ;
32642   Dali::Layer *arg1 = 0 ;
32643   Dali::Layer *result = 0 ;
32644
32645   arg1 = (Dali::Layer *)jarg1;
32646   if (!arg1) {
32647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32648     return 0;
32649   }
32650   {
32651     try {
32652       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32653     } catch (std::out_of_range& e) {
32654       {
32655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32656       };
32657     } catch (std::exception& e) {
32658       {
32659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32660       };
32661     } catch (...) {
32662       {
32663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32664       };
32665     }
32666   }
32667   jresult = (void *)result;
32668   return jresult;
32669 }
32670
32671
32672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32673   void * jresult ;
32674   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32675   Dali::Layer *arg2 = 0 ;
32676   Dali::Layer *result = 0 ;
32677
32678   arg1 = (Dali::Layer *)jarg1;
32679   arg2 = (Dali::Layer *)jarg2;
32680   if (!arg2) {
32681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32682     return 0;
32683   }
32684   {
32685     try {
32686       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32687     } catch (std::out_of_range& e) {
32688       {
32689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32690       };
32691     } catch (std::exception& e) {
32692       {
32693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32698       };
32699     }
32700   }
32701   jresult = (void *)result;
32702   return jresult;
32703 }
32704
32705
32706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32707   unsigned int jresult ;
32708   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32709   unsigned int result;
32710
32711   arg1 = (Dali::Layer *)jarg1;
32712   {
32713     try {
32714       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32715     } catch (std::out_of_range& e) {
32716       {
32717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32718       };
32719     } catch (std::exception& e) {
32720       {
32721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32722       };
32723     } catch (...) {
32724       {
32725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32726       };
32727     }
32728   }
32729   jresult = result;
32730   return jresult;
32731 }
32732
32733
32734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32736
32737   arg1 = (Dali::Layer *)jarg1;
32738   {
32739     try {
32740       (arg1)->Raise();
32741     } catch (std::out_of_range& e) {
32742       {
32743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32744       };
32745     } catch (std::exception& e) {
32746       {
32747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32748       };
32749     } catch (...) {
32750       {
32751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32752       };
32753     }
32754   }
32755 }
32756
32757
32758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32759   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32760
32761   arg1 = (Dali::Layer *)jarg1;
32762   {
32763     try {
32764       (arg1)->Lower();
32765     } catch (std::out_of_range& e) {
32766       {
32767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32768       };
32769     } catch (std::exception& e) {
32770       {
32771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32772       };
32773     } catch (...) {
32774       {
32775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32776       };
32777     }
32778   }
32779 }
32780
32781
32782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32784   Dali::Layer arg2 ;
32785   Dali::Layer *argp2 ;
32786
32787   arg1 = (Dali::Layer *)jarg1;
32788   argp2 = (Dali::Layer *)jarg2;
32789   if (!argp2) {
32790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32791     return ;
32792   }
32793   arg2 = *argp2;
32794   {
32795     try {
32796       (arg1)->RaiseAbove(arg2);
32797     } catch (std::out_of_range& e) {
32798       {
32799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32800       };
32801     } catch (std::exception& e) {
32802       {
32803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32804       };
32805     } catch (...) {
32806       {
32807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32808       };
32809     }
32810   }
32811 }
32812
32813
32814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32816   Dali::Layer arg2 ;
32817   Dali::Layer *argp2 ;
32818
32819   arg1 = (Dali::Layer *)jarg1;
32820   argp2 = (Dali::Layer *)jarg2;
32821   if (!argp2) {
32822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32823     return ;
32824   }
32825   arg2 = *argp2;
32826   {
32827     try {
32828       (arg1)->LowerBelow(arg2);
32829     } catch (std::out_of_range& e) {
32830       {
32831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32832       };
32833     } catch (std::exception& e) {
32834       {
32835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32836       };
32837     } catch (...) {
32838       {
32839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32840       };
32841     }
32842   }
32843 }
32844
32845
32846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32848
32849   arg1 = (Dali::Layer *)jarg1;
32850   {
32851     try {
32852       (arg1)->RaiseToTop();
32853     } catch (std::out_of_range& e) {
32854       {
32855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32856       };
32857     } catch (std::exception& e) {
32858       {
32859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32860       };
32861     } catch (...) {
32862       {
32863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32864       };
32865     }
32866   }
32867 }
32868
32869
32870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32872
32873   arg1 = (Dali::Layer *)jarg1;
32874   {
32875     try {
32876       (arg1)->LowerToBottom();
32877     } catch (std::out_of_range& e) {
32878       {
32879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32880       };
32881     } catch (std::exception& e) {
32882       {
32883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32884       };
32885     } catch (...) {
32886       {
32887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32888       };
32889     }
32890   }
32891 }
32892
32893
32894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32895   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32896   Dali::Layer arg2 ;
32897   Dali::Layer *argp2 ;
32898
32899   arg1 = (Dali::Layer *)jarg1;
32900   argp2 = (Dali::Layer *)jarg2;
32901   if (!argp2) {
32902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32903     return ;
32904   }
32905   arg2 = *argp2;
32906   {
32907     try {
32908       (arg1)->MoveAbove(arg2);
32909     } catch (std::out_of_range& e) {
32910       {
32911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32912       };
32913     } catch (std::exception& e) {
32914       {
32915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32916       };
32917     } catch (...) {
32918       {
32919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32920       };
32921     }
32922   }
32923 }
32924
32925
32926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32927   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32928   Dali::Layer arg2 ;
32929   Dali::Layer *argp2 ;
32930
32931   arg1 = (Dali::Layer *)jarg1;
32932   argp2 = (Dali::Layer *)jarg2;
32933   if (!argp2) {
32934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32935     return ;
32936   }
32937   arg2 = *argp2;
32938   {
32939     try {
32940       (arg1)->MoveBelow(arg2);
32941     } catch (std::out_of_range& e) {
32942       {
32943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32944       };
32945     } catch (std::exception& e) {
32946       {
32947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32948       };
32949     } catch (...) {
32950       {
32951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32952       };
32953     }
32954   }
32955 }
32956
32957
32958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32959   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32960   Dali::Layer::Behavior arg2 ;
32961
32962   arg1 = (Dali::Layer *)jarg1;
32963   arg2 = (Dali::Layer::Behavior)jarg2;
32964   {
32965     try {
32966       (arg1)->SetBehavior(arg2);
32967     } catch (std::out_of_range& e) {
32968       {
32969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32970       };
32971     } catch (std::exception& e) {
32972       {
32973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32974       };
32975     } catch (...) {
32976       {
32977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32978       };
32979     }
32980   }
32981 }
32982
32983
32984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32985   int jresult ;
32986   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32987   Dali::Layer::Behavior result;
32988
32989   arg1 = (Dali::Layer *)jarg1;
32990   {
32991     try {
32992       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32993     } catch (std::out_of_range& e) {
32994       {
32995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32996       };
32997     } catch (std::exception& e) {
32998       {
32999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33000       };
33001     } catch (...) {
33002       {
33003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33004       };
33005     }
33006   }
33007   jresult = (int)result;
33008   return jresult;
33009 }
33010
33011
33012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33013   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33014   bool arg2 ;
33015
33016   arg1 = (Dali::Layer *)jarg1;
33017   arg2 = jarg2 ? true : false;
33018   {
33019     try {
33020       (arg1)->SetClipping(arg2);
33021     } catch (std::out_of_range& e) {
33022       {
33023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33024       };
33025     } catch (std::exception& e) {
33026       {
33027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33028       };
33029     } catch (...) {
33030       {
33031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33032       };
33033     }
33034   }
33035 }
33036
33037
33038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33039   unsigned int jresult ;
33040   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33041   bool result;
33042
33043   arg1 = (Dali::Layer *)jarg1;
33044   {
33045     try {
33046       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33047     } catch (std::out_of_range& e) {
33048       {
33049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33050       };
33051     } catch (std::exception& e) {
33052       {
33053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33054       };
33055     } catch (...) {
33056       {
33057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33058       };
33059     }
33060   }
33061   jresult = result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33067   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33068   int arg2 ;
33069   int arg3 ;
33070   int arg4 ;
33071   int arg5 ;
33072
33073   arg1 = (Dali::Layer *)jarg1;
33074   arg2 = (int)jarg2;
33075   arg3 = (int)jarg3;
33076   arg4 = (int)jarg4;
33077   arg5 = (int)jarg5;
33078   {
33079     try {
33080       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33081     } catch (std::out_of_range& e) {
33082       {
33083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33084       };
33085     } catch (std::exception& e) {
33086       {
33087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33088       };
33089     } catch (...) {
33090       {
33091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33092       };
33093     }
33094   }
33095 }
33096
33097
33098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33099   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33100   Dali::ClippingBox arg2 ;
33101   Dali::ClippingBox *argp2 ;
33102
33103   arg1 = (Dali::Layer *)jarg1;
33104   argp2 = (Dali::ClippingBox *)jarg2;
33105   if (!argp2) {
33106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33107     return ;
33108   }
33109   arg2 = *argp2;
33110   {
33111     try {
33112       (arg1)->SetClippingBox(arg2);
33113     } catch (std::out_of_range& e) {
33114       {
33115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33116       };
33117     } catch (std::exception& e) {
33118       {
33119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33120       };
33121     } catch (...) {
33122       {
33123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33124       };
33125     }
33126   }
33127 }
33128
33129
33130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33131   void * jresult ;
33132   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33133   Dali::ClippingBox result;
33134
33135   arg1 = (Dali::Layer *)jarg1;
33136   {
33137     try {
33138       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33139     } catch (std::out_of_range& e) {
33140       {
33141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33142       };
33143     } catch (std::exception& e) {
33144       {
33145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33146       };
33147     } catch (...) {
33148       {
33149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33150       };
33151     }
33152   }
33153   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33159   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33160   bool arg2 ;
33161
33162   arg1 = (Dali::Layer *)jarg1;
33163   arg2 = jarg2 ? true : false;
33164   {
33165     try {
33166       (arg1)->SetDepthTestDisabled(arg2);
33167     } catch (std::out_of_range& e) {
33168       {
33169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33170       };
33171     } catch (std::exception& e) {
33172       {
33173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33174       };
33175     } catch (...) {
33176       {
33177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33178       };
33179     }
33180   }
33181 }
33182
33183
33184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33185   unsigned int jresult ;
33186   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33187   bool result;
33188
33189   arg1 = (Dali::Layer *)jarg1;
33190   {
33191     try {
33192       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33193     } catch (std::out_of_range& e) {
33194       {
33195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33196       };
33197     } catch (std::exception& e) {
33198       {
33199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33200       };
33201     } catch (...) {
33202       {
33203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33204       };
33205     }
33206   }
33207   jresult = result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33213   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33214   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33215
33216   arg1 = (Dali::Layer *)jarg1;
33217   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33218   {
33219     try {
33220       (arg1)->SetSortFunction(arg2);
33221     } catch (std::out_of_range& e) {
33222       {
33223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33224       };
33225     } catch (std::exception& e) {
33226       {
33227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33228       };
33229     } catch (...) {
33230       {
33231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33232       };
33233     }
33234   }
33235 }
33236
33237
33238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33239   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33240   bool arg2 ;
33241
33242   arg1 = (Dali::Layer *)jarg1;
33243   arg2 = jarg2 ? true : false;
33244   {
33245     try {
33246       (arg1)->SetTouchConsumed(arg2);
33247     } catch (std::out_of_range& e) {
33248       {
33249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33250       };
33251     } catch (std::exception& e) {
33252       {
33253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33254       };
33255     } catch (...) {
33256       {
33257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33258       };
33259     }
33260   }
33261 }
33262
33263
33264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33265   unsigned int jresult ;
33266   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33267   bool result;
33268
33269   arg1 = (Dali::Layer *)jarg1;
33270   {
33271     try {
33272       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33273     } catch (std::out_of_range& e) {
33274       {
33275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33276       };
33277     } catch (std::exception& e) {
33278       {
33279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33280       };
33281     } catch (...) {
33282       {
33283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33284       };
33285     }
33286   }
33287   jresult = result;
33288   return jresult;
33289 }
33290
33291
33292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33293   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33294   bool arg2 ;
33295
33296   arg1 = (Dali::Layer *)jarg1;
33297   arg2 = jarg2 ? true : false;
33298   {
33299     try {
33300       (arg1)->SetHoverConsumed(arg2);
33301     } catch (std::out_of_range& e) {
33302       {
33303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33304       };
33305     } catch (std::exception& e) {
33306       {
33307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33308       };
33309     } catch (...) {
33310       {
33311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33312       };
33313     }
33314   }
33315 }
33316
33317
33318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33319   unsigned int jresult ;
33320   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33321   bool result;
33322
33323   arg1 = (Dali::Layer *)jarg1;
33324   {
33325     try {
33326       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33327     } catch (std::out_of_range& e) {
33328       {
33329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33330       };
33331     } catch (std::exception& e) {
33332       {
33333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33334       };
33335     } catch (...) {
33336       {
33337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33338       };
33339     }
33340   }
33341   jresult = result;
33342   return jresult;
33343 }
33344
33345
33346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33347   void * jresult ;
33348   Dali::Vector4 *result = 0 ;
33349
33350   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33351   jresult = (void *)result;
33352   return jresult;
33353 }
33354
33355
33356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33357   void * jresult ;
33358   Dali::Vector4 *result = 0 ;
33359
33360   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33361   jresult = (void *)result;
33362   return jresult;
33363 }
33364
33365
33366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33367   void * jresult ;
33368   Dali::Stage *result = 0 ;
33369
33370   {
33371     try {
33372       result = (Dali::Stage *)new Dali::Stage();
33373     } catch (std::out_of_range& e) {
33374       {
33375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (std::exception& e) {
33378       {
33379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387   jresult = (void *)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33393   void * jresult ;
33394   Dali::Stage result;
33395
33396   {
33397     try {
33398       result = Dali::Stage::GetCurrent();
33399     } catch (std::out_of_range& e) {
33400       {
33401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33402       };
33403     } catch (std::exception& e) {
33404       {
33405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33406       };
33407     } catch (...) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33410       };
33411     }
33412   }
33413   jresult = new Dali::Stage((const Dali::Stage &)result);
33414   return jresult;
33415 }
33416
33417
33418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33419   unsigned int jresult ;
33420   bool result;
33421
33422   {
33423     try {
33424       result = (bool)Dali::Stage::IsInstalled();
33425     } catch (std::out_of_range& e) {
33426       {
33427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33428       };
33429     } catch (std::exception& e) {
33430       {
33431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33432       };
33433     } catch (...) {
33434       {
33435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33436       };
33437     }
33438   }
33439   jresult = result;
33440   return jresult;
33441 }
33442
33443
33444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33445   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33446
33447   arg1 = (Dali::Stage *)jarg1;
33448   {
33449     try {
33450       delete arg1;
33451     } catch (std::out_of_range& e) {
33452       {
33453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33454       };
33455     } catch (std::exception& e) {
33456       {
33457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33458       };
33459     } catch (...) {
33460       {
33461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33462       };
33463     }
33464   }
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33469   void * jresult ;
33470   Dali::Stage *arg1 = 0 ;
33471   Dali::Stage *result = 0 ;
33472
33473   arg1 = (Dali::Stage *)jarg1;
33474   if (!arg1) {
33475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33476     return 0;
33477   }
33478   {
33479     try {
33480       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33481     } catch (std::out_of_range& e) {
33482       {
33483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (std::exception& e) {
33486       {
33487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33488       };
33489     } catch (...) {
33490       {
33491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33492       };
33493     }
33494   }
33495   jresult = (void *)result;
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33501   void * jresult ;
33502   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33503   Dali::Stage *arg2 = 0 ;
33504   Dali::Stage *result = 0 ;
33505
33506   arg1 = (Dali::Stage *)jarg1;
33507   arg2 = (Dali::Stage *)jarg2;
33508   if (!arg2) {
33509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33510     return 0;
33511   }
33512   {
33513     try {
33514       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33515     } catch (std::out_of_range& e) {
33516       {
33517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33518       };
33519     } catch (std::exception& e) {
33520       {
33521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33522       };
33523     } catch (...) {
33524       {
33525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33526       };
33527     }
33528   }
33529   jresult = (void *)result;
33530   return jresult;
33531 }
33532
33533
33534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33535   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33536   Dali::Actor *arg2 = 0 ;
33537
33538   arg1 = (Dali::Stage *)jarg1;
33539   arg2 = (Dali::Actor *)jarg2;
33540   if (!arg2) {
33541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33542     return ;
33543   }
33544   {
33545     try {
33546       (arg1)->Add(*arg2);
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (...) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33558       };
33559     }
33560   }
33561 }
33562
33563
33564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33566   Dali::Actor *arg2 = 0 ;
33567
33568   arg1 = (Dali::Stage *)jarg1;
33569   arg2 = (Dali::Actor *)jarg2;
33570   if (!arg2) {
33571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33572     return ;
33573   }
33574   {
33575     try {
33576       (arg1)->Remove(*arg2);
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33588       };
33589     }
33590   }
33591 }
33592
33593
33594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33595   void * jresult ;
33596   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33597   Dali::Vector2 result;
33598
33599   arg1 = (Dali::Stage *)jarg1;
33600   {
33601     try {
33602       result = ((Dali::Stage const *)arg1)->GetSize();
33603     } catch (std::out_of_range& e) {
33604       {
33605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33606       };
33607     } catch (std::exception& e) {
33608       {
33609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33610       };
33611     } catch (...) {
33612       {
33613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33614       };
33615     }
33616   }
33617   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33623   void * jresult ;
33624   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33625   Dali::RenderTaskList result;
33626
33627   arg1 = (Dali::Stage *)jarg1;
33628   {
33629     try {
33630       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33631     } catch (std::out_of_range& e) {
33632       {
33633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33634       };
33635     } catch (std::exception& e) {
33636       {
33637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (...) {
33640       {
33641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33642       };
33643     }
33644   }
33645   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33651   unsigned int jresult ;
33652   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33653   unsigned int result;
33654
33655   arg1 = (Dali::Stage *)jarg1;
33656   {
33657     try {
33658       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33659     } catch (std::out_of_range& e) {
33660       {
33661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33662       };
33663     } catch (std::exception& e) {
33664       {
33665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33666       };
33667     } catch (...) {
33668       {
33669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33670       };
33671     }
33672   }
33673   jresult = result;
33674   return jresult;
33675 }
33676
33677
33678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33679   void * jresult ;
33680   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33681   unsigned int arg2 ;
33682   Dali::Layer result;
33683
33684   arg1 = (Dali::Stage *)jarg1;
33685   arg2 = (unsigned int)jarg2;
33686   {
33687     try {
33688       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33689     } catch (std::out_of_range& e) {
33690       {
33691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33692       };
33693     } catch (std::exception& e) {
33694       {
33695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33696       };
33697     } catch (...) {
33698       {
33699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33700       };
33701     }
33702   }
33703   jresult = new Dali::Layer((const Dali::Layer &)result);
33704   return jresult;
33705 }
33706
33707
33708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33709   void * jresult ;
33710   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33711   Dali::Layer result;
33712
33713   arg1 = (Dali::Stage *)jarg1;
33714   {
33715     try {
33716       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (...) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33728       };
33729     }
33730   }
33731   jresult = new Dali::Layer((const Dali::Layer &)result);
33732   return jresult;
33733 }
33734
33735
33736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33737   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33738   Dali::Vector4 arg2 ;
33739   Dali::Vector4 *argp2 ;
33740
33741   arg1 = (Dali::Stage *)jarg1;
33742   argp2 = (Dali::Vector4 *)jarg2;
33743   if (!argp2) {
33744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33745     return ;
33746   }
33747   arg2 = *argp2;
33748   {
33749     try {
33750       (arg1)->SetBackgroundColor(arg2);
33751     } catch (std::out_of_range& e) {
33752       {
33753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33754       };
33755     } catch (std::exception& e) {
33756       {
33757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33758       };
33759     } catch (...) {
33760       {
33761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33762       };
33763     }
33764   }
33765 }
33766
33767
33768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33769   void * jresult ;
33770   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33771   Dali::Vector4 result;
33772
33773   arg1 = (Dali::Stage *)jarg1;
33774   {
33775     try {
33776       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33777     } catch (std::out_of_range& e) {
33778       {
33779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33780       };
33781     } catch (std::exception& e) {
33782       {
33783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33788       };
33789     }
33790   }
33791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33792   return jresult;
33793 }
33794
33795
33796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33797   void * jresult ;
33798   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33799   Dali::Vector2 result;
33800
33801   arg1 = (Dali::Stage *)jarg1;
33802   {
33803     try {
33804       result = ((Dali::Stage const *)arg1)->GetDpi();
33805     } catch (std::out_of_range& e) {
33806       {
33807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33808       };
33809     } catch (std::exception& e) {
33810       {
33811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33812       };
33813     } catch (...) {
33814       {
33815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33816       };
33817     }
33818   }
33819   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33820   return jresult;
33821 }
33822
33823
33824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33825   void * jresult ;
33826   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33827   Dali::ObjectRegistry result;
33828
33829   arg1 = (Dali::Stage *)jarg1;
33830   {
33831     try {
33832       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33833     } catch (std::out_of_range& e) {
33834       {
33835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33836       };
33837     } catch (std::exception& e) {
33838       {
33839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33840       };
33841     } catch (...) {
33842       {
33843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33844       };
33845     }
33846   }
33847   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33848   return jresult;
33849 }
33850
33851
33852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33853   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33854   float arg2 ;
33855
33856   arg1 = (Dali::Stage *)jarg1;
33857   arg2 = (float)jarg2;
33858   {
33859     try {
33860       (arg1)->KeepRendering(arg2);
33861     } catch (std::out_of_range& e) {
33862       {
33863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33864       };
33865     } catch (std::exception& e) {
33866       {
33867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33868       };
33869     } catch (...) {
33870       {
33871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33872       };
33873     }
33874   }
33875 }
33876
33877
33878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33879   void * jresult ;
33880   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33881   Dali::Stage::KeyEventSignalType *result = 0 ;
33882
33883   arg1 = (Dali::Stage *)jarg1;
33884   {
33885     try {
33886       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (...) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33898       };
33899     }
33900   }
33901   jresult = (void *)result;
33902   return jresult;
33903 }
33904
33905
33906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33907   void * jresult ;
33908   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33909   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33910
33911   arg1 = (Dali::Stage *)jarg1;
33912   {
33913     try {
33914       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33915     } catch (std::out_of_range& e) {
33916       {
33917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33918       };
33919     } catch (std::exception& e) {
33920       {
33921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33922       };
33923     } catch (...) {
33924       {
33925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33926       };
33927     }
33928   }
33929   jresult = (void *)result;
33930   return jresult;
33931 }
33932
33933
33934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33935   void * jresult ;
33936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33937   Dali::Stage::TouchSignalType *result = 0 ;
33938
33939   arg1 = (Dali::Stage *)jarg1;
33940   {
33941     try {
33942       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33943     } catch (std::out_of_range& e) {
33944       {
33945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33946       };
33947     } catch (std::exception& e) {
33948       {
33949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (...) {
33952       {
33953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33954       };
33955     }
33956   }
33957   jresult = (void *)result;
33958   return jresult;
33959 }
33960
33961
33962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33963   void * jresult ;
33964   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33965   Dali::Stage::WheelEventSignalType *result = 0 ;
33966
33967   arg1 = (Dali::Stage *)jarg1;
33968   {
33969     try {
33970       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33971     } catch (std::out_of_range& e) {
33972       {
33973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33974       };
33975     } catch (std::exception& e) {
33976       {
33977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33978       };
33979     } catch (...) {
33980       {
33981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33982       };
33983     }
33984   }
33985   jresult = (void *)result;
33986   return jresult;
33987 }
33988
33989
33990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33991   void * jresult ;
33992   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33993   Dali::Stage::ContextStatusSignal *result = 0 ;
33994
33995   arg1 = (Dali::Stage *)jarg1;
33996   {
33997     try {
33998       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33999     } catch (std::out_of_range& e) {
34000       {
34001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34002       };
34003     } catch (std::exception& e) {
34004       {
34005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34010       };
34011     }
34012   }
34013   jresult = (void *)result;
34014   return jresult;
34015 }
34016
34017
34018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34019   void * jresult ;
34020   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34021   Dali::Stage::ContextStatusSignal *result = 0 ;
34022
34023   arg1 = (Dali::Stage *)jarg1;
34024   {
34025     try {
34026       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34027     } catch (std::out_of_range& e) {
34028       {
34029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34030       };
34031     } catch (std::exception& e) {
34032       {
34033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34034       };
34035     } catch (...) {
34036       {
34037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34038       };
34039     }
34040   }
34041   jresult = (void *)result;
34042   return jresult;
34043 }
34044
34045
34046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34047   void * jresult ;
34048   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34049   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34050
34051   arg1 = (Dali::Stage *)jarg1;
34052   {
34053     try {
34054       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34055     } catch (std::out_of_range& e) {
34056       {
34057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34058       };
34059     } catch (std::exception& e) {
34060       {
34061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (...) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34066       };
34067     }
34068   }
34069   jresult = (void *)result;
34070   return jresult;
34071 }
34072
34073
34074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34075   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34076
34077   arg1 = (Dali::RelayoutContainer *)jarg1;
34078   {
34079     try {
34080       delete arg1;
34081     } catch (std::out_of_range& e) {
34082       {
34083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34084       };
34085     } catch (std::exception& e) {
34086       {
34087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34088       };
34089     } catch (...) {
34090       {
34091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34092       };
34093     }
34094   }
34095 }
34096
34097
34098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34099   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34100   Dali::Actor *arg2 = 0 ;
34101   Dali::Vector2 *arg3 = 0 ;
34102
34103   arg1 = (Dali::RelayoutContainer *)jarg1;
34104   arg2 = (Dali::Actor *)jarg2;
34105   if (!arg2) {
34106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34107     return ;
34108   }
34109   arg3 = (Dali::Vector2 *)jarg3;
34110   if (!arg3) {
34111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34112     return ;
34113   }
34114   {
34115     try {
34116       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34117     } catch (std::out_of_range& e) {
34118       {
34119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34120       };
34121     } catch (std::exception& e) {
34122       {
34123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34124       };
34125     } catch (...) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34128       };
34129     }
34130   }
34131 }
34132
34133
34134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34135   void * jresult ;
34136   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34137   Dali::CustomActor result;
34138
34139   arg1 = (Dali::CustomActorImpl *)jarg1;
34140   {
34141     try {
34142       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34143     } catch (std::out_of_range& e) {
34144       {
34145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34146       };
34147     } catch (std::exception& e) {
34148       {
34149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34150       };
34151     } catch (...) {
34152       {
34153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34154       };
34155     }
34156   }
34157   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34158   return jresult;
34159 }
34160
34161
34162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34164   int arg2 ;
34165
34166   arg1 = (Dali::CustomActorImpl *)jarg1;
34167   arg2 = (int)jarg2;
34168   {
34169     try {
34170       (arg1)->OnStageConnection(arg2);
34171     } catch (std::out_of_range& e) {
34172       {
34173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (std::exception& e) {
34176       {
34177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185 }
34186
34187
34188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34189   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34190
34191   arg1 = (Dali::CustomActorImpl *)jarg1;
34192   {
34193     try {
34194       (arg1)->OnStageDisconnection();
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (...) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34206       };
34207     }
34208   }
34209 }
34210
34211
34212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34213   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34214   Dali::Actor *arg2 = 0 ;
34215
34216   arg1 = (Dali::CustomActorImpl *)jarg1;
34217   arg2 = (Dali::Actor *)jarg2;
34218   if (!arg2) {
34219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34220     return ;
34221   }
34222   {
34223     try {
34224       (arg1)->OnChildAdd(*arg2);
34225     } catch (std::out_of_range& e) {
34226       {
34227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34228       };
34229     } catch (std::exception& e) {
34230       {
34231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34232       };
34233     } catch (...) {
34234       {
34235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34236       };
34237     }
34238   }
34239 }
34240
34241
34242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34243   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34244   Dali::Actor *arg2 = 0 ;
34245
34246   arg1 = (Dali::CustomActorImpl *)jarg1;
34247   arg2 = (Dali::Actor *)jarg2;
34248   if (!arg2) {
34249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34250     return ;
34251   }
34252   {
34253     try {
34254       (arg1)->OnChildRemove(*arg2);
34255     } catch (std::out_of_range& e) {
34256       {
34257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34258       };
34259     } catch (std::exception& e) {
34260       {
34261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34262       };
34263     } catch (...) {
34264       {
34265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34266       };
34267     }
34268   }
34269 }
34270
34271
34272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34273   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34274   Dali::Property::Index arg2 ;
34275   Dali::Property::Value arg3 ;
34276   Dali::Property::Value *argp3 ;
34277
34278   arg1 = (Dali::CustomActorImpl *)jarg1;
34279   arg2 = (Dali::Property::Index)jarg2;
34280   argp3 = (Dali::Property::Value *)jarg3;
34281   if (!argp3) {
34282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34283     return ;
34284   }
34285   arg3 = *argp3;
34286   {
34287     try {
34288       (arg1)->OnPropertySet(arg2,arg3);
34289     } catch (std::out_of_range& e) {
34290       {
34291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34292       };
34293     } catch (std::exception& e) {
34294       {
34295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34296       };
34297     } catch (...) {
34298       {
34299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34300       };
34301     }
34302   }
34303 }
34304
34305
34306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34307   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34308   Dali::Vector3 *arg2 = 0 ;
34309
34310   arg1 = (Dali::CustomActorImpl *)jarg1;
34311   arg2 = (Dali::Vector3 *)jarg2;
34312   if (!arg2) {
34313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34314     return ;
34315   }
34316   {
34317     try {
34318       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34319     } catch (std::out_of_range& e) {
34320       {
34321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34322       };
34323     } catch (std::exception& e) {
34324       {
34325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34326       };
34327     } catch (...) {
34328       {
34329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34330       };
34331     }
34332   }
34333 }
34334
34335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34336   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34337   Dali::Animation *arg2 = 0 ;
34338   Dali::Vector3 *arg3 = 0 ;
34339
34340   arg1 = (Dali::CustomActorImpl *)jarg1;
34341   arg2 = (Dali::Animation *)jarg2;
34342   if (!arg2) {
34343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34344     return ;
34345   }
34346   arg3 = (Dali::Vector3 *)jarg3;
34347   if (!arg3) {
34348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34349     return ;
34350   }
34351   {
34352     try {
34353       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34354     } catch (std::out_of_range& e) {
34355       {
34356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34357       };
34358     } catch (std::exception& e) {
34359       {
34360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (...) {
34363       {
34364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34365       };
34366     }
34367   }
34368 }
34369
34370
34371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34372   unsigned int jresult ;
34373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34374   Dali::TouchEvent *arg2 = 0 ;
34375   bool result;
34376
34377   arg1 = (Dali::CustomActorImpl *)jarg1;
34378   arg2 = (Dali::TouchEvent *)jarg2;
34379   if (!arg2) {
34380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34381     return 0;
34382   }
34383   {
34384     try {
34385       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34386     } catch (std::out_of_range& e) {
34387       {
34388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34389       };
34390     } catch (std::exception& e) {
34391       {
34392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34393       };
34394     } catch (...) {
34395       {
34396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34397       };
34398     }
34399   }
34400   jresult = result;
34401   return jresult;
34402 }
34403
34404
34405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34406   unsigned int jresult ;
34407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34408   Dali::HoverEvent *arg2 = 0 ;
34409   bool result;
34410
34411   arg1 = (Dali::CustomActorImpl *)jarg1;
34412   arg2 = (Dali::HoverEvent *)jarg2;
34413   if (!arg2) {
34414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34415     return 0;
34416   }
34417   {
34418     try {
34419       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34420     } catch (std::out_of_range& e) {
34421       {
34422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34423       };
34424     } catch (std::exception& e) {
34425       {
34426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34427       };
34428     } catch (...) {
34429       {
34430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34431       };
34432     }
34433   }
34434   jresult = result;
34435   return jresult;
34436 }
34437
34438
34439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34440   unsigned int jresult ;
34441   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34442   Dali::KeyEvent *arg2 = 0 ;
34443   bool result;
34444
34445   arg1 = (Dali::CustomActorImpl *)jarg1;
34446   arg2 = (Dali::KeyEvent *)jarg2;
34447   if (!arg2) {
34448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34449     return 0;
34450   }
34451   {
34452     try {
34453       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34454     } catch (std::out_of_range& e) {
34455       {
34456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34457       };
34458     } catch (std::exception& e) {
34459       {
34460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34461       };
34462     } catch (...) {
34463       {
34464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34465       };
34466     }
34467   }
34468   jresult = result;
34469   return jresult;
34470 }
34471
34472
34473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34474   unsigned int jresult ;
34475   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34476   Dali::WheelEvent *arg2 = 0 ;
34477   bool result;
34478
34479   arg1 = (Dali::CustomActorImpl *)jarg1;
34480   arg2 = (Dali::WheelEvent *)jarg2;
34481   if (!arg2) {
34482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34483     return 0;
34484   }
34485   {
34486     try {
34487       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34488     } catch (std::out_of_range& e) {
34489       {
34490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34491       };
34492     } catch (std::exception& e) {
34493       {
34494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34495       };
34496     } catch (...) {
34497       {
34498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34499       };
34500     }
34501   }
34502   jresult = result;
34503   return jresult;
34504 }
34505
34506
34507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::Vector2 *arg2 = 0 ;
34510   Dali::RelayoutContainer *arg3 = 0 ;
34511
34512   arg1 = (Dali::CustomActorImpl *)jarg1;
34513   arg2 = (Dali::Vector2 *)jarg2;
34514   if (!arg2) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34516     return ;
34517   }
34518   arg3 = (Dali::RelayoutContainer *)jarg3;
34519   if (!arg3) {
34520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34521     return ;
34522   }
34523   {
34524     try {
34525       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34526     } catch (std::out_of_range& e) {
34527       {
34528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34529       };
34530     } catch (std::exception& e) {
34531       {
34532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34533       };
34534     } catch (...) {
34535       {
34536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34537       };
34538     }
34539   }
34540 }
34541
34542
34543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34544   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34545   Dali::ResizePolicy::Type arg2 ;
34546   Dali::Dimension::Type arg3 ;
34547
34548   arg1 = (Dali::CustomActorImpl *)jarg1;
34549   arg2 = (Dali::ResizePolicy::Type)jarg2;
34550   arg3 = (Dali::Dimension::Type)jarg3;
34551   {
34552     try {
34553       (arg1)->OnSetResizePolicy(arg2,arg3);
34554     } catch (std::out_of_range& e) {
34555       {
34556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34557       };
34558     } catch (std::exception& e) {
34559       {
34560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34561       };
34562     } catch (...) {
34563       {
34564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34565       };
34566     }
34567   }
34568 }
34569
34570
34571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34572   void * jresult ;
34573   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34574   Dali::Vector3 result;
34575
34576   arg1 = (Dali::CustomActorImpl *)jarg1;
34577   {
34578     try {
34579       result = (arg1)->GetNaturalSize();
34580     } catch (std::out_of_range& e) {
34581       {
34582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34583       };
34584     } catch (std::exception& e) {
34585       {
34586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34587       };
34588     } catch (...) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34591       };
34592     }
34593   }
34594   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34595   return jresult;
34596 }
34597
34598
34599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34600   float jresult ;
34601   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34602   Dali::Actor *arg2 = 0 ;
34603   Dali::Dimension::Type arg3 ;
34604   float result;
34605
34606   arg1 = (Dali::CustomActorImpl *)jarg1;
34607   arg2 = (Dali::Actor *)jarg2;
34608   if (!arg2) {
34609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34610     return 0;
34611   }
34612   arg3 = (Dali::Dimension::Type)jarg3;
34613   {
34614     try {
34615       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34616     } catch (std::out_of_range& e) {
34617       {
34618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34619       };
34620     } catch (std::exception& e) {
34621       {
34622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34623       };
34624     } catch (...) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34627       };
34628     }
34629   }
34630   jresult = result;
34631   return jresult;
34632 }
34633
34634
34635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34636   float jresult ;
34637   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34638   float arg2 ;
34639   float result;
34640
34641   arg1 = (Dali::CustomActorImpl *)jarg1;
34642   arg2 = (float)jarg2;
34643   {
34644     try {
34645       result = (float)(arg1)->GetHeightForWidth(arg2);
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34653       };
34654     } catch (...) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34657       };
34658     }
34659   }
34660   jresult = result;
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34666   float jresult ;
34667   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34668   float arg2 ;
34669   float result;
34670
34671   arg1 = (Dali::CustomActorImpl *)jarg1;
34672   arg2 = (float)jarg2;
34673   {
34674     try {
34675       result = (float)(arg1)->GetWidthForHeight(arg2);
34676     } catch (std::out_of_range& e) {
34677       {
34678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34679       };
34680     } catch (std::exception& e) {
34681       {
34682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34687       };
34688     }
34689   }
34690   jresult = result;
34691   return jresult;
34692 }
34693
34694
34695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34696   unsigned int jresult ;
34697   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34698   Dali::Dimension::Type arg2 ;
34699   bool result;
34700
34701   arg1 = (Dali::CustomActorImpl *)jarg1;
34702   arg2 = (Dali::Dimension::Type)jarg2;
34703   {
34704     try {
34705       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34717       };
34718     }
34719   }
34720   jresult = result;
34721   return jresult;
34722 }
34723
34724
34725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34726   unsigned int jresult ;
34727   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34728   bool result;
34729
34730   arg1 = (Dali::CustomActorImpl *)jarg1;
34731   {
34732     try {
34733       result = (bool)(arg1)->RelayoutDependentOnChildren();
34734     } catch (std::out_of_range& e) {
34735       {
34736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34737       };
34738     } catch (std::exception& e) {
34739       {
34740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34741       };
34742     } catch (...) {
34743       {
34744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34745       };
34746     }
34747   }
34748   jresult = result;
34749   return jresult;
34750 }
34751
34752
34753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34754   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34755   Dali::Dimension::Type arg2 ;
34756
34757   arg1 = (Dali::CustomActorImpl *)jarg1;
34758   arg2 = (Dali::Dimension::Type)jarg2;
34759   {
34760     try {
34761       (arg1)->OnCalculateRelayoutSize(arg2);
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34769       };
34770     } catch (...) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34773       };
34774     }
34775   }
34776 }
34777
34778
34779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34780   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34781   float arg2 ;
34782   Dali::Dimension::Type arg3 ;
34783
34784   arg1 = (Dali::CustomActorImpl *)jarg1;
34785   arg2 = (float)jarg2;
34786   arg3 = (Dali::Dimension::Type)jarg3;
34787   {
34788     try {
34789       (arg1)->OnLayoutNegotiated(arg2,arg3);
34790     } catch (std::out_of_range& e) {
34791       {
34792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34793       };
34794     } catch (std::exception& e) {
34795       {
34796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34797       };
34798     } catch (...) {
34799       {
34800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34801       };
34802     }
34803   }
34804 }
34805
34806
34807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34808   unsigned int jresult ;
34809   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34810   bool result;
34811
34812   arg1 = (Dali::CustomActorImpl *)jarg1;
34813   {
34814     try {
34815       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34816     } catch (std::out_of_range& e) {
34817       {
34818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34819       };
34820     } catch (std::exception& e) {
34821       {
34822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34823       };
34824     } catch (...) {
34825       {
34826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34827       };
34828     }
34829   }
34830   jresult = result;
34831   return jresult;
34832 }
34833
34834
34835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34836   unsigned int jresult ;
34837   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34838   bool result;
34839
34840   arg1 = (Dali::CustomActorImpl *)jarg1;
34841   {
34842     try {
34843       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34855       };
34856     }
34857   }
34858   jresult = result;
34859   return jresult;
34860 }
34861
34862
34863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34864   unsigned int jresult ;
34865   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34866   bool result;
34867
34868   arg1 = (Dali::CustomActorImpl *)jarg1;
34869   {
34870     try {
34871       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34879       };
34880     } catch (...) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34883       };
34884     }
34885   }
34886   jresult = result;
34887   return jresult;
34888 }
34889
34890
34891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34892   unsigned int jresult ;
34893   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34894   bool result;
34895
34896   arg1 = (Dali::CustomActorImpl *)jarg1;
34897   {
34898     try {
34899       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34900     } catch (std::out_of_range& e) {
34901       {
34902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34903       };
34904     } catch (std::exception& e) {
34905       {
34906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (...) {
34909       {
34910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34911       };
34912     }
34913   }
34914   jresult = result;
34915   return jresult;
34916 }
34917
34918
34919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34920   void * jresult ;
34921   Dali::CustomActor *result = 0 ;
34922
34923   {
34924     try {
34925       result = (Dali::CustomActor *)new Dali::CustomActor();
34926     } catch (std::out_of_range& e) {
34927       {
34928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34929       };
34930     } catch (std::exception& e) {
34931       {
34932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34933       };
34934     } catch (...) {
34935       {
34936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34937       };
34938     }
34939   }
34940   jresult = (void *)result;
34941   return jresult;
34942 }
34943
34944
34945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34946   void * jresult ;
34947   Dali::BaseHandle arg1 ;
34948   Dali::BaseHandle *argp1 ;
34949   Dali::CustomActor result;
34950
34951   argp1 = (Dali::BaseHandle *)jarg1;
34952   if (!argp1) {
34953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34954     return 0;
34955   }
34956   arg1 = *argp1;
34957   {
34958     try {
34959       result = Dali::CustomActor::DownCast(arg1);
34960     } catch (std::out_of_range& e) {
34961       {
34962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34963       };
34964     } catch (std::exception& e) {
34965       {
34966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34971       };
34972     }
34973   }
34974   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34975   return jresult;
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34980   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34981
34982   arg1 = (Dali::CustomActor *)jarg1;
34983   {
34984     try {
34985       delete arg1;
34986     } catch (std::out_of_range& e) {
34987       {
34988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34989       };
34990     } catch (std::exception& e) {
34991       {
34992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34993       };
34994     } catch (...) {
34995       {
34996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34997       };
34998     }
34999   }
35000 }
35001
35002
35003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35004   void * jresult ;
35005   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35006   Dali::CustomActorImpl *result = 0 ;
35007
35008   arg1 = (Dali::CustomActor *)jarg1;
35009   {
35010     try {
35011       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35012     } catch (std::out_of_range& e) {
35013       {
35014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35015       };
35016     } catch (std::exception& e) {
35017       {
35018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35019       };
35020     } catch (...) {
35021       {
35022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35023       };
35024     }
35025   }
35026   jresult = (void *)result;
35027   return jresult;
35028 }
35029
35030
35031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35032   void * jresult ;
35033   Dali::CustomActorImpl *arg1 = 0 ;
35034   Dali::CustomActor *result = 0 ;
35035
35036   arg1 = (Dali::CustomActorImpl *)jarg1;
35037   if (!arg1) {
35038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35039     return 0;
35040   }
35041   {
35042     try {
35043       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35044     } catch (std::out_of_range& e) {
35045       {
35046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35047       };
35048     } catch (std::exception& e) {
35049       {
35050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35051       };
35052     } catch (...) {
35053       {
35054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35055       };
35056     }
35057   }
35058   jresult = (void *)result;
35059   return jresult;
35060 }
35061
35062
35063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35064   void * jresult ;
35065   Dali::CustomActor *arg1 = 0 ;
35066   Dali::CustomActor *result = 0 ;
35067
35068   arg1 = (Dali::CustomActor *)jarg1;
35069   if (!arg1) {
35070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35071     return 0;
35072   }
35073   {
35074     try {
35075       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35076     } catch (std::out_of_range& e) {
35077       {
35078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35079       };
35080     } catch (std::exception& e) {
35081       {
35082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35083       };
35084     } catch (...) {
35085       {
35086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35087       };
35088     }
35089   }
35090   jresult = (void *)result;
35091   return jresult;
35092 }
35093
35094
35095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35096   void * jresult ;
35097   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35098   Dali::CustomActor *arg2 = 0 ;
35099   Dali::CustomActor *result = 0 ;
35100
35101   arg1 = (Dali::CustomActor *)jarg1;
35102   arg2 = (Dali::CustomActor *)jarg2;
35103   if (!arg2) {
35104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35105     return 0;
35106   }
35107   {
35108     try {
35109       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35110     } catch (std::out_of_range& e) {
35111       {
35112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35113       };
35114     } catch (std::exception& e) {
35115       {
35116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35117       };
35118     } catch (...) {
35119       {
35120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35121       };
35122     }
35123   }
35124   jresult = (void *)result;
35125   return jresult;
35126 }
35127
35128
35129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35130   int jresult ;
35131   int result;
35132
35133   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35134   jresult = (int)result;
35135   return jresult;
35136 }
35137
35138
35139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35140   int jresult ;
35141   int result;
35142
35143   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35144   jresult = (int)result;
35145   return jresult;
35146 }
35147
35148
35149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35150   int jresult ;
35151   int result;
35152
35153   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35154   jresult = (int)result;
35155   return jresult;
35156 }
35157
35158
35159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35160   int jresult ;
35161   int result;
35162
35163   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35164   jresult = (int)result;
35165   return jresult;
35166 }
35167
35168
35169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35170   int jresult ;
35171   int result;
35172
35173   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35174   jresult = (int)result;
35175   return jresult;
35176 }
35177
35178
35179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35180   int jresult ;
35181   int result;
35182
35183   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35184   jresult = (int)result;
35185   return jresult;
35186 }
35187
35188
35189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35190   int jresult ;
35191   int result;
35192
35193   result = (int)Dali::PanGestureDetector::Property::PANNING;
35194   jresult = (int)result;
35195   return jresult;
35196 }
35197
35198
35199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35200   void * jresult ;
35201   Dali::PanGestureDetector::Property *result = 0 ;
35202
35203   {
35204     try {
35205       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35206     } catch (std::out_of_range& e) {
35207       {
35208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35209       };
35210     } catch (std::exception& e) {
35211       {
35212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35213       };
35214     } catch (...) {
35215       {
35216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35217       };
35218     }
35219   }
35220   jresult = (void *)result;
35221   return jresult;
35222 }
35223
35224
35225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35226   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35227
35228   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35229   {
35230     try {
35231       delete arg1;
35232     } catch (std::out_of_range& e) {
35233       {
35234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35235       };
35236     } catch (std::exception& e) {
35237       {
35238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35243       };
35244     }
35245   }
35246 }
35247
35248
35249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35250   void * jresult ;
35251   Dali::Radian *result = 0 ;
35252
35253   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35254   jresult = (void *)result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35260   void * jresult ;
35261   Dali::Radian *result = 0 ;
35262
35263   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35264   jresult = (void *)result;
35265   return jresult;
35266 }
35267
35268
35269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35270   void * jresult ;
35271   Dali::Radian *result = 0 ;
35272
35273   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35274   jresult = (void *)result;
35275   return jresult;
35276 }
35277
35278
35279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35280   void * jresult ;
35281   Dali::Radian *result = 0 ;
35282
35283   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35284   jresult = (void *)result;
35285   return jresult;
35286 }
35287
35288
35289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35290   void * jresult ;
35291   Dali::Radian *result = 0 ;
35292
35293   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35294   jresult = (void *)result;
35295   return jresult;
35296 }
35297
35298
35299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35300   void * jresult ;
35301   Dali::Radian *result = 0 ;
35302
35303   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35304   jresult = (void *)result;
35305   return jresult;
35306 }
35307
35308
35309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35310   void * jresult ;
35311   Dali::Radian *result = 0 ;
35312
35313   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35314   jresult = (void *)result;
35315   return jresult;
35316 }
35317
35318
35319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35320   void * jresult ;
35321   Dali::PanGestureDetector *result = 0 ;
35322
35323   {
35324     try {
35325       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35326     } catch (std::out_of_range& e) {
35327       {
35328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (std::exception& e) {
35331       {
35332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35333       };
35334     } catch (...) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35337       };
35338     }
35339   }
35340   jresult = (void *)result;
35341   return jresult;
35342 }
35343
35344
35345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35346   void * jresult ;
35347   Dali::PanGestureDetector result;
35348
35349   {
35350     try {
35351       result = Dali::PanGestureDetector::New();
35352     } catch (std::out_of_range& e) {
35353       {
35354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35355       };
35356     } catch (std::exception& e) {
35357       {
35358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35359       };
35360     } catch (...) {
35361       {
35362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35363       };
35364     }
35365   }
35366   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35367   return jresult;
35368 }
35369
35370
35371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35372   void * jresult ;
35373   Dali::BaseHandle arg1 ;
35374   Dali::BaseHandle *argp1 ;
35375   Dali::PanGestureDetector result;
35376
35377   argp1 = (Dali::BaseHandle *)jarg1;
35378   if (!argp1) {
35379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35380     return 0;
35381   }
35382   arg1 = *argp1;
35383   {
35384     try {
35385       result = Dali::PanGestureDetector::DownCast(arg1);
35386     } catch (std::out_of_range& e) {
35387       {
35388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35389       };
35390     } catch (std::exception& e) {
35391       {
35392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35393       };
35394     } catch (...) {
35395       {
35396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35397       };
35398     }
35399   }
35400   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35401   return jresult;
35402 }
35403
35404
35405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35406   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35407
35408   arg1 = (Dali::PanGestureDetector *)jarg1;
35409   {
35410     try {
35411       delete arg1;
35412     } catch (std::out_of_range& e) {
35413       {
35414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35415       };
35416     } catch (std::exception& e) {
35417       {
35418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35419       };
35420     } catch (...) {
35421       {
35422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35423       };
35424     }
35425   }
35426 }
35427
35428
35429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35430   void * jresult ;
35431   Dali::PanGestureDetector *arg1 = 0 ;
35432   Dali::PanGestureDetector *result = 0 ;
35433
35434   arg1 = (Dali::PanGestureDetector *)jarg1;
35435   if (!arg1) {
35436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35437     return 0;
35438   }
35439   {
35440     try {
35441       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35442     } catch (std::out_of_range& e) {
35443       {
35444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35445       };
35446     } catch (std::exception& e) {
35447       {
35448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35453       };
35454     }
35455   }
35456   jresult = (void *)result;
35457   return jresult;
35458 }
35459
35460
35461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35462   void * jresult ;
35463   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35464   Dali::PanGestureDetector *arg2 = 0 ;
35465   Dali::PanGestureDetector *result = 0 ;
35466
35467   arg1 = (Dali::PanGestureDetector *)jarg1;
35468   arg2 = (Dali::PanGestureDetector *)jarg2;
35469   if (!arg2) {
35470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35471     return 0;
35472   }
35473   {
35474     try {
35475       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35476     } catch (std::out_of_range& e) {
35477       {
35478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35479       };
35480     } catch (std::exception& e) {
35481       {
35482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35483       };
35484     } catch (...) {
35485       {
35486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35487       };
35488     }
35489   }
35490   jresult = (void *)result;
35491   return jresult;
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35496   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35497   unsigned int arg2 ;
35498
35499   arg1 = (Dali::PanGestureDetector *)jarg1;
35500   arg2 = (unsigned int)jarg2;
35501   {
35502     try {
35503       (arg1)->SetMinimumTouchesRequired(arg2);
35504     } catch (std::out_of_range& e) {
35505       {
35506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35507       };
35508     } catch (std::exception& e) {
35509       {
35510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35511       };
35512     } catch (...) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35515       };
35516     }
35517   }
35518 }
35519
35520
35521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35522   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35523   unsigned int arg2 ;
35524
35525   arg1 = (Dali::PanGestureDetector *)jarg1;
35526   arg2 = (unsigned int)jarg2;
35527   {
35528     try {
35529       (arg1)->SetMaximumTouchesRequired(arg2);
35530     } catch (std::out_of_range& e) {
35531       {
35532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35533       };
35534     } catch (std::exception& e) {
35535       {
35536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35537       };
35538     } catch (...) {
35539       {
35540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35541       };
35542     }
35543   }
35544 }
35545
35546
35547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35548   unsigned int jresult ;
35549   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35550   unsigned int result;
35551
35552   arg1 = (Dali::PanGestureDetector *)jarg1;
35553   {
35554     try {
35555       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35556     } catch (std::out_of_range& e) {
35557       {
35558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35559       };
35560     } catch (std::exception& e) {
35561       {
35562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35563       };
35564     } catch (...) {
35565       {
35566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35567       };
35568     }
35569   }
35570   jresult = result;
35571   return jresult;
35572 }
35573
35574
35575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35576   unsigned int jresult ;
35577   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35578   unsigned int result;
35579
35580   arg1 = (Dali::PanGestureDetector *)jarg1;
35581   {
35582     try {
35583       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35584     } catch (std::out_of_range& e) {
35585       {
35586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35587       };
35588     } catch (std::exception& e) {
35589       {
35590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35591       };
35592     } catch (...) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35595       };
35596     }
35597   }
35598   jresult = result;
35599   return jresult;
35600 }
35601
35602
35603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35604   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35605   Dali::Radian arg2 ;
35606   Dali::Radian arg3 ;
35607   Dali::Radian *argp2 ;
35608   Dali::Radian *argp3 ;
35609
35610   arg1 = (Dali::PanGestureDetector *)jarg1;
35611   argp2 = (Dali::Radian *)jarg2;
35612   if (!argp2) {
35613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35614     return ;
35615   }
35616   arg2 = *argp2;
35617   argp3 = (Dali::Radian *)jarg3;
35618   if (!argp3) {
35619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35620     return ;
35621   }
35622   arg3 = *argp3;
35623   {
35624     try {
35625       (arg1)->AddAngle(arg2,arg3);
35626     } catch (std::out_of_range& e) {
35627       {
35628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35629       };
35630     } catch (std::exception& e) {
35631       {
35632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (...) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35637       };
35638     }
35639   }
35640 }
35641
35642
35643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35644   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35645   Dali::Radian arg2 ;
35646   Dali::Radian *argp2 ;
35647
35648   arg1 = (Dali::PanGestureDetector *)jarg1;
35649   argp2 = (Dali::Radian *)jarg2;
35650   if (!argp2) {
35651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35652     return ;
35653   }
35654   arg2 = *argp2;
35655   {
35656     try {
35657       (arg1)->AddAngle(arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (...) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35669       };
35670     }
35671   }
35672 }
35673
35674
35675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35676   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35677   Dali::Radian arg2 ;
35678   Dali::Radian arg3 ;
35679   Dali::Radian *argp2 ;
35680   Dali::Radian *argp3 ;
35681
35682   arg1 = (Dali::PanGestureDetector *)jarg1;
35683   argp2 = (Dali::Radian *)jarg2;
35684   if (!argp2) {
35685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35686     return ;
35687   }
35688   arg2 = *argp2;
35689   argp3 = (Dali::Radian *)jarg3;
35690   if (!argp3) {
35691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35692     return ;
35693   }
35694   arg3 = *argp3;
35695   {
35696     try {
35697       (arg1)->AddDirection(arg2,arg3);
35698     } catch (std::out_of_range& e) {
35699       {
35700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35701       };
35702     } catch (std::exception& e) {
35703       {
35704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35709       };
35710     }
35711   }
35712 }
35713
35714
35715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35716   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35717   Dali::Radian arg2 ;
35718   Dali::Radian *argp2 ;
35719
35720   arg1 = (Dali::PanGestureDetector *)jarg1;
35721   argp2 = (Dali::Radian *)jarg2;
35722   if (!argp2) {
35723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35724     return ;
35725   }
35726   arg2 = *argp2;
35727   {
35728     try {
35729       (arg1)->AddDirection(arg2);
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (...) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35741       };
35742     }
35743   }
35744 }
35745
35746
35747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35748   unsigned long jresult ;
35749   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35750   size_t result;
35751
35752   arg1 = (Dali::PanGestureDetector *)jarg1;
35753   {
35754     try {
35755       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35763       };
35764     } catch (...) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35767       };
35768     }
35769   }
35770   jresult = (unsigned long)result;
35771   return jresult;
35772 }
35773
35774
35775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35776   void * jresult ;
35777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35778   size_t arg2 ;
35779   Dali::PanGestureDetector::AngleThresholdPair result;
35780
35781   arg1 = (Dali::PanGestureDetector *)jarg1;
35782   arg2 = (size_t)jarg2;
35783   {
35784     try {
35785       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35786     } catch (std::out_of_range& e) {
35787       {
35788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35789       };
35790     } catch (std::exception& e) {
35791       {
35792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35793       };
35794     } catch (...) {
35795       {
35796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35797       };
35798     }
35799   }
35800   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35801   return jresult;
35802 }
35803
35804
35805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35806   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35807
35808   arg1 = (Dali::PanGestureDetector *)jarg1;
35809   {
35810     try {
35811       (arg1)->ClearAngles();
35812     } catch (std::out_of_range& e) {
35813       {
35814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35815       };
35816     } catch (std::exception& e) {
35817       {
35818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35819       };
35820     } catch (...) {
35821       {
35822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35823       };
35824     }
35825   }
35826 }
35827
35828
35829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35830   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35831   Dali::Radian arg2 ;
35832   Dali::Radian *argp2 ;
35833
35834   arg1 = (Dali::PanGestureDetector *)jarg1;
35835   argp2 = (Dali::Radian *)jarg2;
35836   if (!argp2) {
35837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35838     return ;
35839   }
35840   arg2 = *argp2;
35841   {
35842     try {
35843       (arg1)->RemoveAngle(arg2);
35844     } catch (std::out_of_range& e) {
35845       {
35846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35847       };
35848     } catch (std::exception& e) {
35849       {
35850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35851       };
35852     } catch (...) {
35853       {
35854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35855       };
35856     }
35857   }
35858 }
35859
35860
35861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35863   Dali::Radian arg2 ;
35864   Dali::Radian *argp2 ;
35865
35866   arg1 = (Dali::PanGestureDetector *)jarg1;
35867   argp2 = (Dali::Radian *)jarg2;
35868   if (!argp2) {
35869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35870     return ;
35871   }
35872   arg2 = *argp2;
35873   {
35874     try {
35875       (arg1)->RemoveDirection(arg2);
35876     } catch (std::out_of_range& e) {
35877       {
35878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35879       };
35880     } catch (std::exception& e) {
35881       {
35882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35883       };
35884     } catch (...) {
35885       {
35886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35887       };
35888     }
35889   }
35890 }
35891
35892
35893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35894   void * jresult ;
35895   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35896   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35897
35898   arg1 = (Dali::PanGestureDetector *)jarg1;
35899   {
35900     try {
35901       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35902     } catch (std::out_of_range& e) {
35903       {
35904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35905       };
35906     } catch (std::exception& e) {
35907       {
35908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35913       };
35914     }
35915   }
35916   jresult = (void *)result;
35917   return jresult;
35918 }
35919
35920
35921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35922   Dali::PanGesture *arg1 = 0 ;
35923
35924   arg1 = (Dali::PanGesture *)jarg1;
35925   if (!arg1) {
35926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35927     return ;
35928   }
35929   {
35930     try {
35931       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35932     } catch (std::out_of_range& e) {
35933       {
35934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35935       };
35936     } catch (std::exception& e) {
35937       {
35938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35943       };
35944     }
35945   }
35946 }
35947
35948
35949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35950   void * jresult ;
35951   Dali::PanGesture *result = 0 ;
35952
35953   {
35954     try {
35955       result = (Dali::PanGesture *)new Dali::PanGesture();
35956     } catch (std::out_of_range& e) {
35957       {
35958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (std::exception& e) {
35961       {
35962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35963       };
35964     } catch (...) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35967       };
35968     }
35969   }
35970   jresult = (void *)result;
35971   return jresult;
35972 }
35973
35974
35975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35976   void * jresult ;
35977   Dali::Gesture::State arg1 ;
35978   Dali::PanGesture *result = 0 ;
35979
35980   arg1 = (Dali::Gesture::State)jarg1;
35981   {
35982     try {
35983       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35984     } catch (std::out_of_range& e) {
35985       {
35986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35987       };
35988     } catch (std::exception& e) {
35989       {
35990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35991       };
35992     } catch (...) {
35993       {
35994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35995       };
35996     }
35997   }
35998   jresult = (void *)result;
35999   return jresult;
36000 }
36001
36002
36003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36004   void * jresult ;
36005   Dali::PanGesture *arg1 = 0 ;
36006   Dali::PanGesture *result = 0 ;
36007
36008   arg1 = (Dali::PanGesture *)jarg1;
36009   if (!arg1) {
36010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36011     return 0;
36012   }
36013   {
36014     try {
36015       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36016     } catch (std::out_of_range& e) {
36017       {
36018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36019       };
36020     } catch (std::exception& e) {
36021       {
36022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36023       };
36024     } catch (...) {
36025       {
36026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36027       };
36028     }
36029   }
36030   jresult = (void *)result;
36031   return jresult;
36032 }
36033
36034
36035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36036   void * jresult ;
36037   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36038   Dali::PanGesture *arg2 = 0 ;
36039   Dali::PanGesture *result = 0 ;
36040
36041   arg1 = (Dali::PanGesture *)jarg1;
36042   arg2 = (Dali::PanGesture *)jarg2;
36043   if (!arg2) {
36044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36045     return 0;
36046   }
36047   {
36048     try {
36049       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36050     } catch (std::out_of_range& e) {
36051       {
36052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36053       };
36054     } catch (std::exception& e) {
36055       {
36056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36061       };
36062     }
36063   }
36064   jresult = (void *)result;
36065   return jresult;
36066 }
36067
36068
36069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36070   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36071
36072   arg1 = (Dali::PanGesture *)jarg1;
36073   {
36074     try {
36075       delete arg1;
36076     } catch (std::out_of_range& e) {
36077       {
36078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36079       };
36080     } catch (std::exception& e) {
36081       {
36082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36083       };
36084     } catch (...) {
36085       {
36086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36087       };
36088     }
36089   }
36090 }
36091
36092
36093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36094   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36095   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36096
36097   arg1 = (Dali::PanGesture *)jarg1;
36098   arg2 = (Dali::Vector2 *)jarg2;
36099   if (arg1) (arg1)->velocity = *arg2;
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36104   void * jresult ;
36105   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36106   Dali::Vector2 *result = 0 ;
36107
36108   arg1 = (Dali::PanGesture *)jarg1;
36109   result = (Dali::Vector2 *)& ((arg1)->velocity);
36110   jresult = (void *)result;
36111   return jresult;
36112 }
36113
36114
36115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36116   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36117   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36118
36119   arg1 = (Dali::PanGesture *)jarg1;
36120   arg2 = (Dali::Vector2 *)jarg2;
36121   if (arg1) (arg1)->displacement = *arg2;
36122 }
36123
36124
36125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36126   void * jresult ;
36127   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36128   Dali::Vector2 *result = 0 ;
36129
36130   arg1 = (Dali::PanGesture *)jarg1;
36131   result = (Dali::Vector2 *)& ((arg1)->displacement);
36132   jresult = (void *)result;
36133   return jresult;
36134 }
36135
36136
36137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36138   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36139   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36140
36141   arg1 = (Dali::PanGesture *)jarg1;
36142   arg2 = (Dali::Vector2 *)jarg2;
36143   if (arg1) (arg1)->position = *arg2;
36144 }
36145
36146
36147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36148   void * jresult ;
36149   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36150   Dali::Vector2 *result = 0 ;
36151
36152   arg1 = (Dali::PanGesture *)jarg1;
36153   result = (Dali::Vector2 *)& ((arg1)->position);
36154   jresult = (void *)result;
36155   return jresult;
36156 }
36157
36158
36159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36160   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36161   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36162
36163   arg1 = (Dali::PanGesture *)jarg1;
36164   arg2 = (Dali::Vector2 *)jarg2;
36165   if (arg1) (arg1)->screenVelocity = *arg2;
36166 }
36167
36168
36169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36170   void * jresult ;
36171   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36172   Dali::Vector2 *result = 0 ;
36173
36174   arg1 = (Dali::PanGesture *)jarg1;
36175   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36176   jresult = (void *)result;
36177   return jresult;
36178 }
36179
36180
36181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36182   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36183   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36184
36185   arg1 = (Dali::PanGesture *)jarg1;
36186   arg2 = (Dali::Vector2 *)jarg2;
36187   if (arg1) (arg1)->screenDisplacement = *arg2;
36188 }
36189
36190
36191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36192   void * jresult ;
36193   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36194   Dali::Vector2 *result = 0 ;
36195
36196   arg1 = (Dali::PanGesture *)jarg1;
36197   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36198   jresult = (void *)result;
36199   return jresult;
36200 }
36201
36202
36203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36204   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36205   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36206
36207   arg1 = (Dali::PanGesture *)jarg1;
36208   arg2 = (Dali::Vector2 *)jarg2;
36209   if (arg1) (arg1)->screenPosition = *arg2;
36210 }
36211
36212
36213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36214   void * jresult ;
36215   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36216   Dali::Vector2 *result = 0 ;
36217
36218   arg1 = (Dali::PanGesture *)jarg1;
36219   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36220   jresult = (void *)result;
36221   return jresult;
36222 }
36223
36224
36225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36227   unsigned int arg2 ;
36228
36229   arg1 = (Dali::PanGesture *)jarg1;
36230   arg2 = (unsigned int)jarg2;
36231   if (arg1) (arg1)->numberOfTouches = arg2;
36232 }
36233
36234
36235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36236   unsigned int jresult ;
36237   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36238   unsigned int result;
36239
36240   arg1 = (Dali::PanGesture *)jarg1;
36241   result = (unsigned int) ((arg1)->numberOfTouches);
36242   jresult = result;
36243   return jresult;
36244 }
36245
36246
36247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36248   float jresult ;
36249   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36250   float result;
36251
36252   arg1 = (Dali::PanGesture *)jarg1;
36253   {
36254     try {
36255       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36256     } catch (std::out_of_range& e) {
36257       {
36258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36259       };
36260     } catch (std::exception& e) {
36261       {
36262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36263       };
36264     } catch (...) {
36265       {
36266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36267       };
36268     }
36269   }
36270   jresult = result;
36271   return jresult;
36272 }
36273
36274
36275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36276   float jresult ;
36277   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36278   float result;
36279
36280   arg1 = (Dali::PanGesture *)jarg1;
36281   {
36282     try {
36283       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36284     } catch (std::out_of_range& e) {
36285       {
36286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36287       };
36288     } catch (std::exception& e) {
36289       {
36290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (...) {
36293       {
36294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36295       };
36296     }
36297   }
36298   jresult = result;
36299   return jresult;
36300 }
36301
36302
36303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36304   float jresult ;
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   float result;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   {
36310     try {
36311       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36312     } catch (std::out_of_range& e) {
36313       {
36314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36315       };
36316     } catch (std::exception& e) {
36317       {
36318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36319       };
36320     } catch (...) {
36321       {
36322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36323       };
36324     }
36325   }
36326   jresult = result;
36327   return jresult;
36328 }
36329
36330
36331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36332   float jresult ;
36333   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36334   float result;
36335
36336   arg1 = (Dali::PanGesture *)jarg1;
36337   {
36338     try {
36339       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36340     } catch (std::out_of_range& e) {
36341       {
36342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36343       };
36344     } catch (std::exception& e) {
36345       {
36346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36347       };
36348     } catch (...) {
36349       {
36350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36351       };
36352     }
36353   }
36354   jresult = result;
36355   return jresult;
36356 }
36357
36358
36359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36360   void * jresult ;
36361   Dali::PinchGestureDetector *result = 0 ;
36362
36363   {
36364     try {
36365       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36366     } catch (std::out_of_range& e) {
36367       {
36368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36369       };
36370     } catch (std::exception& e) {
36371       {
36372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36373       };
36374     } catch (...) {
36375       {
36376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36377       };
36378     }
36379   }
36380   jresult = (void *)result;
36381   return jresult;
36382 }
36383
36384
36385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36386   void * jresult ;
36387   Dali::PinchGestureDetector result;
36388
36389   {
36390     try {
36391       result = Dali::PinchGestureDetector::New();
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36412   void * jresult ;
36413   Dali::BaseHandle arg1 ;
36414   Dali::BaseHandle *argp1 ;
36415   Dali::PinchGestureDetector result;
36416
36417   argp1 = (Dali::BaseHandle *)jarg1;
36418   if (!argp1) {
36419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36420     return 0;
36421   }
36422   arg1 = *argp1;
36423   {
36424     try {
36425       result = Dali::PinchGestureDetector::DownCast(arg1);
36426     } catch (std::out_of_range& e) {
36427       {
36428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36429       };
36430     } catch (std::exception& e) {
36431       {
36432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36433       };
36434     } catch (...) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36437       };
36438     }
36439   }
36440   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36446   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36447
36448   arg1 = (Dali::PinchGestureDetector *)jarg1;
36449   {
36450     try {
36451       delete arg1;
36452     } catch (std::out_of_range& e) {
36453       {
36454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36455       };
36456     } catch (std::exception& e) {
36457       {
36458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36459       };
36460     } catch (...) {
36461       {
36462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36463       };
36464     }
36465   }
36466 }
36467
36468
36469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36470   void * jresult ;
36471   Dali::PinchGestureDetector *arg1 = 0 ;
36472   Dali::PinchGestureDetector *result = 0 ;
36473
36474   arg1 = (Dali::PinchGestureDetector *)jarg1;
36475   if (!arg1) {
36476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36477     return 0;
36478   }
36479   {
36480     try {
36481       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36482     } catch (std::out_of_range& e) {
36483       {
36484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (std::exception& e) {
36487       {
36488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (...) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36493       };
36494     }
36495   }
36496   jresult = (void *)result;
36497   return jresult;
36498 }
36499
36500
36501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36502   void * jresult ;
36503   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36504   Dali::PinchGestureDetector *arg2 = 0 ;
36505   Dali::PinchGestureDetector *result = 0 ;
36506
36507   arg1 = (Dali::PinchGestureDetector *)jarg1;
36508   arg2 = (Dali::PinchGestureDetector *)jarg2;
36509   if (!arg2) {
36510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36511     return 0;
36512   }
36513   {
36514     try {
36515       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36516     } catch (std::out_of_range& e) {
36517       {
36518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36519       };
36520     } catch (std::exception& e) {
36521       {
36522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36527       };
36528     }
36529   }
36530   jresult = (void *)result;
36531   return jresult;
36532 }
36533
36534
36535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36536   void * jresult ;
36537   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36538   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36539
36540   arg1 = (Dali::PinchGestureDetector *)jarg1;
36541   {
36542     try {
36543       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36544     } catch (std::out_of_range& e) {
36545       {
36546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36547       };
36548     } catch (std::exception& e) {
36549       {
36550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36551       };
36552     } catch (...) {
36553       {
36554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36555       };
36556     }
36557   }
36558   jresult = (void *)result;
36559   return jresult;
36560 }
36561
36562
36563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36564   void * jresult ;
36565   Dali::Gesture::State arg1 ;
36566   Dali::PinchGesture *result = 0 ;
36567
36568   arg1 = (Dali::Gesture::State)jarg1;
36569   {
36570     try {
36571       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36572     } catch (std::out_of_range& e) {
36573       {
36574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36575       };
36576     } catch (std::exception& e) {
36577       {
36578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36579       };
36580     } catch (...) {
36581       {
36582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36583       };
36584     }
36585   }
36586   jresult = (void *)result;
36587   return jresult;
36588 }
36589
36590
36591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36592   void * jresult ;
36593   Dali::PinchGesture *arg1 = 0 ;
36594   Dali::PinchGesture *result = 0 ;
36595
36596   arg1 = (Dali::PinchGesture *)jarg1;
36597   if (!arg1) {
36598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36599     return 0;
36600   }
36601   {
36602     try {
36603       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36604     } catch (std::out_of_range& e) {
36605       {
36606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (std::exception& e) {
36609       {
36610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36615       };
36616     }
36617   }
36618   jresult = (void *)result;
36619   return jresult;
36620 }
36621
36622
36623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36624   void * jresult ;
36625   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36626   Dali::PinchGesture *arg2 = 0 ;
36627   Dali::PinchGesture *result = 0 ;
36628
36629   arg1 = (Dali::PinchGesture *)jarg1;
36630   arg2 = (Dali::PinchGesture *)jarg2;
36631   if (!arg2) {
36632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36633     return 0;
36634   }
36635   {
36636     try {
36637       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36638     } catch (std::out_of_range& e) {
36639       {
36640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36641       };
36642     } catch (std::exception& e) {
36643       {
36644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36645       };
36646     } catch (...) {
36647       {
36648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36649       };
36650     }
36651   }
36652   jresult = (void *)result;
36653   return jresult;
36654 }
36655
36656
36657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36658   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36659
36660   arg1 = (Dali::PinchGesture *)jarg1;
36661   {
36662     try {
36663       delete arg1;
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36671       };
36672     } catch (...) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36675       };
36676     }
36677   }
36678 }
36679
36680
36681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36682   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36683   float arg2 ;
36684
36685   arg1 = (Dali::PinchGesture *)jarg1;
36686   arg2 = (float)jarg2;
36687   if (arg1) (arg1)->scale = arg2;
36688 }
36689
36690
36691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36692   float jresult ;
36693   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36694   float result;
36695
36696   arg1 = (Dali::PinchGesture *)jarg1;
36697   result = (float) ((arg1)->scale);
36698   jresult = result;
36699   return jresult;
36700 }
36701
36702
36703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36704   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36705   float arg2 ;
36706
36707   arg1 = (Dali::PinchGesture *)jarg1;
36708   arg2 = (float)jarg2;
36709   if (arg1) (arg1)->speed = arg2;
36710 }
36711
36712
36713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36714   float jresult ;
36715   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36716   float result;
36717
36718   arg1 = (Dali::PinchGesture *)jarg1;
36719   result = (float) ((arg1)->speed);
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36726   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36727   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36728
36729   arg1 = (Dali::PinchGesture *)jarg1;
36730   arg2 = (Dali::Vector2 *)jarg2;
36731   if (arg1) (arg1)->screenCenterPoint = *arg2;
36732 }
36733
36734
36735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36736   void * jresult ;
36737   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36738   Dali::Vector2 *result = 0 ;
36739
36740   arg1 = (Dali::PinchGesture *)jarg1;
36741   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36742   jresult = (void *)result;
36743   return jresult;
36744 }
36745
36746
36747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36748   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36749   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36750
36751   arg1 = (Dali::PinchGesture *)jarg1;
36752   arg2 = (Dali::Vector2 *)jarg2;
36753   if (arg1) (arg1)->localCenterPoint = *arg2;
36754 }
36755
36756
36757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36758   void * jresult ;
36759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36760   Dali::Vector2 *result = 0 ;
36761
36762   arg1 = (Dali::PinchGesture *)jarg1;
36763   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36764   jresult = (void *)result;
36765   return jresult;
36766 }
36767
36768
36769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36770   void * jresult ;
36771   Dali::TapGestureDetector *result = 0 ;
36772
36773   {
36774     try {
36775       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36776     } catch (std::out_of_range& e) {
36777       {
36778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36779       };
36780     } catch (std::exception& e) {
36781       {
36782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36783       };
36784     } catch (...) {
36785       {
36786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36787       };
36788     }
36789   }
36790   jresult = (void *)result;
36791   return jresult;
36792 }
36793
36794
36795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36796   void * jresult ;
36797   Dali::TapGestureDetector result;
36798
36799   {
36800     try {
36801       result = Dali::TapGestureDetector::New();
36802     } catch (std::out_of_range& e) {
36803       {
36804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (std::exception& e) {
36807       {
36808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36809       };
36810     } catch (...) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36813       };
36814     }
36815   }
36816   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36817   return jresult;
36818 }
36819
36820
36821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36822   void * jresult ;
36823   unsigned int arg1 ;
36824   Dali::TapGestureDetector result;
36825
36826   arg1 = (unsigned int)jarg1;
36827   {
36828     try {
36829       result = Dali::TapGestureDetector::New(arg1);
36830     } catch (std::out_of_range& e) {
36831       {
36832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36833       };
36834     } catch (std::exception& e) {
36835       {
36836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36837       };
36838     } catch (...) {
36839       {
36840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36841       };
36842     }
36843   }
36844   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36850   void * jresult ;
36851   Dali::BaseHandle arg1 ;
36852   Dali::BaseHandle *argp1 ;
36853   Dali::TapGestureDetector result;
36854
36855   argp1 = (Dali::BaseHandle *)jarg1;
36856   if (!argp1) {
36857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36858     return 0;
36859   }
36860   arg1 = *argp1;
36861   {
36862     try {
36863       result = Dali::TapGestureDetector::DownCast(arg1);
36864     } catch (std::out_of_range& e) {
36865       {
36866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36867       };
36868     } catch (std::exception& e) {
36869       {
36870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (...) {
36873       {
36874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36875       };
36876     }
36877   }
36878   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36879   return jresult;
36880 }
36881
36882
36883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36884   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36885
36886   arg1 = (Dali::TapGestureDetector *)jarg1;
36887   {
36888     try {
36889       delete arg1;
36890     } catch (std::out_of_range& e) {
36891       {
36892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36893       };
36894     } catch (std::exception& e) {
36895       {
36896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36897       };
36898     } catch (...) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36901       };
36902     }
36903   }
36904 }
36905
36906
36907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36908   void * jresult ;
36909   Dali::TapGestureDetector *arg1 = 0 ;
36910   Dali::TapGestureDetector *result = 0 ;
36911
36912   arg1 = (Dali::TapGestureDetector *)jarg1;
36913   if (!arg1) {
36914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36915     return 0;
36916   }
36917   {
36918     try {
36919       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36920     } catch (std::out_of_range& e) {
36921       {
36922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36923       };
36924     } catch (std::exception& e) {
36925       {
36926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36927       };
36928     } catch (...) {
36929       {
36930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36931       };
36932     }
36933   }
36934   jresult = (void *)result;
36935   return jresult;
36936 }
36937
36938
36939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36940   void * jresult ;
36941   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36942   Dali::TapGestureDetector *arg2 = 0 ;
36943   Dali::TapGestureDetector *result = 0 ;
36944
36945   arg1 = (Dali::TapGestureDetector *)jarg1;
36946   arg2 = (Dali::TapGestureDetector *)jarg2;
36947   if (!arg2) {
36948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36949     return 0;
36950   }
36951   {
36952     try {
36953       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36954     } catch (std::out_of_range& e) {
36955       {
36956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (std::exception& e) {
36959       {
36960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36961       };
36962     } catch (...) {
36963       {
36964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36965       };
36966     }
36967   }
36968   jresult = (void *)result;
36969   return jresult;
36970 }
36971
36972
36973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36974   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36975   unsigned int arg2 ;
36976
36977   arg1 = (Dali::TapGestureDetector *)jarg1;
36978   arg2 = (unsigned int)jarg2;
36979   {
36980     try {
36981       (arg1)->SetMinimumTapsRequired(arg2);
36982     } catch (std::out_of_range& e) {
36983       {
36984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36985       };
36986     } catch (std::exception& e) {
36987       {
36988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36989       };
36990     } catch (...) {
36991       {
36992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36993       };
36994     }
36995   }
36996 }
36997
36998
36999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37000   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37001   unsigned int arg2 ;
37002
37003   arg1 = (Dali::TapGestureDetector *)jarg1;
37004   arg2 = (unsigned int)jarg2;
37005   {
37006     try {
37007       (arg1)->SetMaximumTapsRequired(arg2);
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37015       };
37016     } catch (...) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37019       };
37020     }
37021   }
37022 }
37023
37024
37025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37026   unsigned int jresult ;
37027   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37028   unsigned int result;
37029
37030   arg1 = (Dali::TapGestureDetector *)jarg1;
37031   {
37032     try {
37033       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37034     } catch (std::out_of_range& e) {
37035       {
37036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37037       };
37038     } catch (std::exception& e) {
37039       {
37040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (...) {
37043       {
37044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37045       };
37046     }
37047   }
37048   jresult = result;
37049   return jresult;
37050 }
37051
37052
37053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37054   unsigned int jresult ;
37055   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37056   unsigned int result;
37057
37058   arg1 = (Dali::TapGestureDetector *)jarg1;
37059   {
37060     try {
37061       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37062     } catch (std::out_of_range& e) {
37063       {
37064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37065       };
37066     } catch (std::exception& e) {
37067       {
37068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (...) {
37071       {
37072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37073       };
37074     }
37075   }
37076   jresult = result;
37077   return jresult;
37078 }
37079
37080
37081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37082   void * jresult ;
37083   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37084   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37085
37086   arg1 = (Dali::TapGestureDetector *)jarg1;
37087   {
37088     try {
37089       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37090     } catch (std::out_of_range& e) {
37091       {
37092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37093       };
37094     } catch (std::exception& e) {
37095       {
37096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37097       };
37098     } catch (...) {
37099       {
37100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37101       };
37102     }
37103   }
37104   jresult = (void *)result;
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37110   void * jresult ;
37111   Dali::TapGesture *result = 0 ;
37112
37113   {
37114     try {
37115       result = (Dali::TapGesture *)new Dali::TapGesture();
37116     } catch (std::out_of_range& e) {
37117       {
37118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37119       };
37120     } catch (std::exception& e) {
37121       {
37122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37123       };
37124     } catch (...) {
37125       {
37126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37127       };
37128     }
37129   }
37130   jresult = (void *)result;
37131   return jresult;
37132 }
37133
37134
37135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37136   void * jresult ;
37137   Dali::TapGesture *arg1 = 0 ;
37138   Dali::TapGesture *result = 0 ;
37139
37140   arg1 = (Dali::TapGesture *)jarg1;
37141   if (!arg1) {
37142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37143     return 0;
37144   }
37145   {
37146     try {
37147       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37148     } catch (std::out_of_range& e) {
37149       {
37150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37151       };
37152     } catch (std::exception& e) {
37153       {
37154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37155       };
37156     } catch (...) {
37157       {
37158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37159       };
37160     }
37161   }
37162   jresult = (void *)result;
37163   return jresult;
37164 }
37165
37166
37167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37168   void * jresult ;
37169   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37170   Dali::TapGesture *arg2 = 0 ;
37171   Dali::TapGesture *result = 0 ;
37172
37173   arg1 = (Dali::TapGesture *)jarg1;
37174   arg2 = (Dali::TapGesture *)jarg2;
37175   if (!arg2) {
37176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37177     return 0;
37178   }
37179   {
37180     try {
37181       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37182     } catch (std::out_of_range& e) {
37183       {
37184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37185       };
37186     } catch (std::exception& e) {
37187       {
37188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37189       };
37190     } catch (...) {
37191       {
37192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37193       };
37194     }
37195   }
37196   jresult = (void *)result;
37197   return jresult;
37198 }
37199
37200
37201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37202   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37203
37204   arg1 = (Dali::TapGesture *)jarg1;
37205   {
37206     try {
37207       delete arg1;
37208     } catch (std::out_of_range& e) {
37209       {
37210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37211       };
37212     } catch (std::exception& e) {
37213       {
37214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37215       };
37216     } catch (...) {
37217       {
37218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37219       };
37220     }
37221   }
37222 }
37223
37224
37225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37226   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37227   unsigned int arg2 ;
37228
37229   arg1 = (Dali::TapGesture *)jarg1;
37230   arg2 = (unsigned int)jarg2;
37231   if (arg1) (arg1)->numberOfTaps = arg2;
37232 }
37233
37234
37235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37236   unsigned int jresult ;
37237   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37238   unsigned int result;
37239
37240   arg1 = (Dali::TapGesture *)jarg1;
37241   result = (unsigned int) ((arg1)->numberOfTaps);
37242   jresult = result;
37243   return jresult;
37244 }
37245
37246
37247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37248   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37249   unsigned int arg2 ;
37250
37251   arg1 = (Dali::TapGesture *)jarg1;
37252   arg2 = (unsigned int)jarg2;
37253   if (arg1) (arg1)->numberOfTouches = arg2;
37254 }
37255
37256
37257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37258   unsigned int jresult ;
37259   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37260   unsigned int result;
37261
37262   arg1 = (Dali::TapGesture *)jarg1;
37263   result = (unsigned int) ((arg1)->numberOfTouches);
37264   jresult = result;
37265   return jresult;
37266 }
37267
37268
37269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37270   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37271   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37272
37273   arg1 = (Dali::TapGesture *)jarg1;
37274   arg2 = (Dali::Vector2 *)jarg2;
37275   if (arg1) (arg1)->screenPoint = *arg2;
37276 }
37277
37278
37279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37280   void * jresult ;
37281   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37282   Dali::Vector2 *result = 0 ;
37283
37284   arg1 = (Dali::TapGesture *)jarg1;
37285   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37286   jresult = (void *)result;
37287   return jresult;
37288 }
37289
37290
37291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37292   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37293   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37294
37295   arg1 = (Dali::TapGesture *)jarg1;
37296   arg2 = (Dali::Vector2 *)jarg2;
37297   if (arg1) (arg1)->localPoint = *arg2;
37298 }
37299
37300
37301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37302   void * jresult ;
37303   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37304   Dali::Vector2 *result = 0 ;
37305
37306   arg1 = (Dali::TapGesture *)jarg1;
37307   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37314   void * jresult ;
37315   Dali::AlphaFunction *result = 0 ;
37316
37317   {
37318     try {
37319       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37320     } catch (std::out_of_range& e) {
37321       {
37322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37323       };
37324     } catch (std::exception& e) {
37325       {
37326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37327       };
37328     } catch (...) {
37329       {
37330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37331       };
37332     }
37333   }
37334   jresult = (void *)result;
37335   return jresult;
37336 }
37337
37338
37339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37340   void * jresult ;
37341   Dali::AlphaFunction::BuiltinFunction arg1 ;
37342   Dali::AlphaFunction *result = 0 ;
37343
37344   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37345   {
37346     try {
37347       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37348     } catch (std::out_of_range& e) {
37349       {
37350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37351       };
37352     } catch (std::exception& e) {
37353       {
37354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37355       };
37356     } catch (...) {
37357       {
37358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37359       };
37360     }
37361   }
37362   jresult = (void *)result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37368   void * jresult ;
37369   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37370   Dali::AlphaFunction *result = 0 ;
37371
37372   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37373   {
37374     try {
37375       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37376     } catch (std::out_of_range& e) {
37377       {
37378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37379       };
37380     } catch (std::exception& e) {
37381       {
37382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37383       };
37384     } catch (...) {
37385       {
37386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37387       };
37388     }
37389   }
37390   jresult = (void *)result;
37391   return jresult;
37392 }
37393
37394
37395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37396   void * jresult ;
37397   Dali::Vector2 *arg1 = 0 ;
37398   Dali::Vector2 *arg2 = 0 ;
37399   Dali::AlphaFunction *result = 0 ;
37400
37401   arg1 = (Dali::Vector2 *)jarg1;
37402   if (!arg1) {
37403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37404     return 0;
37405   }
37406   arg2 = (Dali::Vector2 *)jarg2;
37407   if (!arg2) {
37408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37409     return 0;
37410   }
37411   {
37412     try {
37413       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37414     } catch (std::out_of_range& e) {
37415       {
37416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37417       };
37418     } catch (std::exception& e) {
37419       {
37420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37421       };
37422     } catch (...) {
37423       {
37424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37425       };
37426     }
37427   }
37428   jresult = (void *)result;
37429   return jresult;
37430 }
37431
37432
37433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37434   void * jresult ;
37435   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37436   Dali::Vector4 result;
37437
37438   arg1 = (Dali::AlphaFunction *)jarg1;
37439   {
37440     try {
37441       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37442     } catch (std::out_of_range& e) {
37443       {
37444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37445       };
37446     } catch (std::exception& e) {
37447       {
37448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (...) {
37451       {
37452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37453       };
37454     }
37455   }
37456   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37457   return jresult;
37458 }
37459
37460
37461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37462   void * jresult ;
37463   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37464   Dali::AlphaFunctionPrototype result;
37465
37466   arg1 = (Dali::AlphaFunction *)jarg1;
37467   {
37468     try {
37469       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37470     } catch (std::out_of_range& e) {
37471       {
37472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37473       };
37474     } catch (std::exception& e) {
37475       {
37476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37477       };
37478     } catch (...) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37481       };
37482     }
37483   }
37484   jresult = (void *)result;
37485   return jresult;
37486 }
37487
37488
37489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37490   int jresult ;
37491   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37492   Dali::AlphaFunction::BuiltinFunction result;
37493
37494   arg1 = (Dali::AlphaFunction *)jarg1;
37495   {
37496     try {
37497       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37498     } catch (std::out_of_range& e) {
37499       {
37500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37501       };
37502     } catch (std::exception& e) {
37503       {
37504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37505       };
37506     } catch (...) {
37507       {
37508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37509       };
37510     }
37511   }
37512   jresult = (int)result;
37513   return jresult;
37514 }
37515
37516
37517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37518   int jresult ;
37519   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37520   Dali::AlphaFunction::Mode result;
37521
37522   arg1 = (Dali::AlphaFunction *)jarg1;
37523   {
37524     try {
37525       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (...) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37537       };
37538     }
37539   }
37540   jresult = (int)result;
37541   return jresult;
37542 }
37543
37544
37545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37546   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37547
37548   arg1 = (Dali::AlphaFunction *)jarg1;
37549   {
37550     try {
37551       delete arg1;
37552     } catch (std::out_of_range& e) {
37553       {
37554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37555       };
37556     } catch (std::exception& e) {
37557       {
37558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37559       };
37560     } catch (...) {
37561       {
37562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37563       };
37564     }
37565   }
37566 }
37567
37568
37569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37570   void * jresult ;
37571   Dali::KeyFrames result;
37572
37573   {
37574     try {
37575       result = Dali::KeyFrames::New();
37576     } catch (std::out_of_range& e) {
37577       {
37578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37579       };
37580     } catch (std::exception& e) {
37581       {
37582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37583       };
37584     } catch (...) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37587       };
37588     }
37589   }
37590   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37591   return jresult;
37592 }
37593
37594
37595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37596   void * jresult ;
37597   Dali::BaseHandle arg1 ;
37598   Dali::BaseHandle *argp1 ;
37599   Dali::KeyFrames result;
37600
37601   argp1 = (Dali::BaseHandle *)jarg1;
37602   if (!argp1) {
37603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37604     return 0;
37605   }
37606   arg1 = *argp1;
37607   {
37608     try {
37609       result = Dali::KeyFrames::DownCast(arg1);
37610     } catch (std::out_of_range& e) {
37611       {
37612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37613       };
37614     } catch (std::exception& e) {
37615       {
37616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37617       };
37618     } catch (...) {
37619       {
37620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37621       };
37622     }
37623   }
37624   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37625   return jresult;
37626 }
37627
37628
37629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37630   void * jresult ;
37631   Dali::KeyFrames *result = 0 ;
37632
37633   {
37634     try {
37635       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37636     } catch (std::out_of_range& e) {
37637       {
37638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37639       };
37640     } catch (std::exception& e) {
37641       {
37642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37643       };
37644     } catch (...) {
37645       {
37646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37647       };
37648     }
37649   }
37650   jresult = (void *)result;
37651   return jresult;
37652 }
37653
37654
37655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37656   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37657
37658   arg1 = (Dali::KeyFrames *)jarg1;
37659   {
37660     try {
37661       delete arg1;
37662     } catch (std::out_of_range& e) {
37663       {
37664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (std::exception& e) {
37667       {
37668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676 }
37677
37678
37679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37680   void * jresult ;
37681   Dali::KeyFrames *arg1 = 0 ;
37682   Dali::KeyFrames *result = 0 ;
37683
37684   arg1 = (Dali::KeyFrames *)jarg1;
37685   if (!arg1) {
37686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37687     return 0;
37688   }
37689   {
37690     try {
37691       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37692     } catch (std::out_of_range& e) {
37693       {
37694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37695       };
37696     } catch (std::exception& e) {
37697       {
37698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37699       };
37700     } catch (...) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37703       };
37704     }
37705   }
37706   jresult = (void *)result;
37707   return jresult;
37708 }
37709
37710
37711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37712   void * jresult ;
37713   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37714   Dali::KeyFrames *arg2 = 0 ;
37715   Dali::KeyFrames *result = 0 ;
37716
37717   arg1 = (Dali::KeyFrames *)jarg1;
37718   arg2 = (Dali::KeyFrames *)jarg2;
37719   if (!arg2) {
37720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37721     return 0;
37722   }
37723   {
37724     try {
37725       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37726     } catch (std::out_of_range& e) {
37727       {
37728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37729       };
37730     } catch (std::exception& e) {
37731       {
37732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37733       };
37734     } catch (...) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37737       };
37738     }
37739   }
37740   jresult = (void *)result;
37741   return jresult;
37742 }
37743
37744
37745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37746   int jresult ;
37747   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37748   Dali::Property::Type result;
37749
37750   arg1 = (Dali::KeyFrames *)jarg1;
37751   {
37752     try {
37753       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37754     } catch (std::out_of_range& e) {
37755       {
37756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37757       };
37758     } catch (std::exception& e) {
37759       {
37760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (...) {
37763       {
37764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37765       };
37766     }
37767   }
37768   jresult = (int)result;
37769   return jresult;
37770 }
37771
37772
37773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37774   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37775   float arg2 ;
37776   Dali::Property::Value arg3 ;
37777   Dali::Property::Value *argp3 ;
37778
37779   arg1 = (Dali::KeyFrames *)jarg1;
37780   arg2 = (float)jarg2;
37781   argp3 = (Dali::Property::Value *)jarg3;
37782   if (!argp3) {
37783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37784     return ;
37785   }
37786   arg3 = *argp3;
37787   {
37788     try {
37789       (arg1)->Add(arg2,arg3);
37790     } catch (std::out_of_range& e) {
37791       {
37792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (std::exception& e) {
37795       {
37796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804 }
37805
37806
37807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37808   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37809   float arg2 ;
37810   Dali::Property::Value arg3 ;
37811   Dali::AlphaFunction arg4 ;
37812   Dali::Property::Value *argp3 ;
37813   Dali::AlphaFunction *argp4 ;
37814
37815   arg1 = (Dali::KeyFrames *)jarg1;
37816   arg2 = (float)jarg2;
37817   argp3 = (Dali::Property::Value *)jarg3;
37818   if (!argp3) {
37819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37820     return ;
37821   }
37822   arg3 = *argp3;
37823   argp4 = (Dali::AlphaFunction *)jarg4;
37824   if (!argp4) {
37825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37826     return ;
37827   }
37828   arg4 = *argp4;
37829   {
37830     try {
37831       (arg1)->Add(arg2,arg3,arg4);
37832     } catch (std::out_of_range& e) {
37833       {
37834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37835       };
37836     } catch (std::exception& e) {
37837       {
37838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37843       };
37844     }
37845   }
37846 }
37847
37848
37849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37850   int jresult ;
37851   int result;
37852
37853   result = (int)Dali::Path::Property::POINTS;
37854   jresult = (int)result;
37855   return jresult;
37856 }
37857
37858
37859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37860   int jresult ;
37861   int result;
37862
37863   result = (int)Dali::Path::Property::CONTROL_POINTS;
37864   jresult = (int)result;
37865   return jresult;
37866 }
37867
37868
37869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37870   void * jresult ;
37871   Dali::Path::Property *result = 0 ;
37872
37873   {
37874     try {
37875       result = (Dali::Path::Property *)new Dali::Path::Property();
37876     } catch (std::out_of_range& e) {
37877       {
37878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37879       };
37880     } catch (std::exception& e) {
37881       {
37882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37883       };
37884     } catch (...) {
37885       {
37886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37887       };
37888     }
37889   }
37890   jresult = (void *)result;
37891   return jresult;
37892 }
37893
37894
37895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37896   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37897
37898   arg1 = (Dali::Path::Property *)jarg1;
37899   {
37900     try {
37901       delete arg1;
37902     } catch (std::out_of_range& e) {
37903       {
37904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (std::exception& e) {
37907       {
37908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916 }
37917
37918
37919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37920   void * jresult ;
37921   Dali::Path result;
37922
37923   {
37924     try {
37925       result = Dali::Path::New();
37926     } catch (std::out_of_range& e) {
37927       {
37928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37929       };
37930     } catch (std::exception& e) {
37931       {
37932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37933       };
37934     } catch (...) {
37935       {
37936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37937       };
37938     }
37939   }
37940   jresult = new Dali::Path((const Dali::Path &)result);
37941   return jresult;
37942 }
37943
37944
37945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37946   void * jresult ;
37947   Dali::BaseHandle arg1 ;
37948   Dali::BaseHandle *argp1 ;
37949   Dali::Path result;
37950
37951   argp1 = (Dali::BaseHandle *)jarg1;
37952   if (!argp1) {
37953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37954     return 0;
37955   }
37956   arg1 = *argp1;
37957   {
37958     try {
37959       result = Dali::Path::DownCast(arg1);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37967       };
37968     } catch (...) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37971       };
37972     }
37973   }
37974   jresult = new Dali::Path((const Dali::Path &)result);
37975   return jresult;
37976 }
37977
37978
37979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37980   void * jresult ;
37981   Dali::Path *result = 0 ;
37982
37983   {
37984     try {
37985       result = (Dali::Path *)new Dali::Path();
37986     } catch (std::out_of_range& e) {
37987       {
37988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37989       };
37990     } catch (std::exception& e) {
37991       {
37992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37993       };
37994     } catch (...) {
37995       {
37996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37997       };
37998     }
37999   }
38000   jresult = (void *)result;
38001   return jresult;
38002 }
38003
38004
38005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38006   Dali::Path *arg1 = (Dali::Path *) 0 ;
38007
38008   arg1 = (Dali::Path *)jarg1;
38009   {
38010     try {
38011       delete arg1;
38012     } catch (std::out_of_range& e) {
38013       {
38014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38015       };
38016     } catch (std::exception& e) {
38017       {
38018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38019       };
38020     } catch (...) {
38021       {
38022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38023       };
38024     }
38025   }
38026 }
38027
38028
38029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38030   void * jresult ;
38031   Dali::Path *arg1 = 0 ;
38032   Dali::Path *result = 0 ;
38033
38034   arg1 = (Dali::Path *)jarg1;
38035   if (!arg1) {
38036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38037     return 0;
38038   }
38039   {
38040     try {
38041       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (...) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38053       };
38054     }
38055   }
38056   jresult = (void *)result;
38057   return jresult;
38058 }
38059
38060
38061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38062   void * jresult ;
38063   Dali::Path *arg1 = (Dali::Path *) 0 ;
38064   Dali::Path *arg2 = 0 ;
38065   Dali::Path *result = 0 ;
38066
38067   arg1 = (Dali::Path *)jarg1;
38068   arg2 = (Dali::Path *)jarg2;
38069   if (!arg2) {
38070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38071     return 0;
38072   }
38073   {
38074     try {
38075       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38076     } catch (std::out_of_range& e) {
38077       {
38078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38079       };
38080     } catch (std::exception& e) {
38081       {
38082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38083       };
38084     } catch (...) {
38085       {
38086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38087       };
38088     }
38089   }
38090   jresult = (void *)result;
38091   return jresult;
38092 }
38093
38094
38095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38096   Dali::Path *arg1 = (Dali::Path *) 0 ;
38097   Dali::Vector3 *arg2 = 0 ;
38098
38099   arg1 = (Dali::Path *)jarg1;
38100   arg2 = (Dali::Vector3 *)jarg2;
38101   if (!arg2) {
38102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38103     return ;
38104   }
38105   {
38106     try {
38107       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38108     } catch (std::out_of_range& e) {
38109       {
38110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38111       };
38112     } catch (std::exception& e) {
38113       {
38114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38115       };
38116     } catch (...) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38119       };
38120     }
38121   }
38122 }
38123
38124
38125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38126   Dali::Path *arg1 = (Dali::Path *) 0 ;
38127   Dali::Vector3 *arg2 = 0 ;
38128
38129   arg1 = (Dali::Path *)jarg1;
38130   arg2 = (Dali::Vector3 *)jarg2;
38131   if (!arg2) {
38132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38133     return ;
38134   }
38135   {
38136     try {
38137       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38138     } catch (std::out_of_range& e) {
38139       {
38140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38141       };
38142     } catch (std::exception& e) {
38143       {
38144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38145       };
38146     } catch (...) {
38147       {
38148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38149       };
38150     }
38151   }
38152 }
38153
38154
38155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38156   Dali::Path *arg1 = (Dali::Path *) 0 ;
38157   float arg2 ;
38158
38159   arg1 = (Dali::Path *)jarg1;
38160   arg2 = (float)jarg2;
38161   {
38162     try {
38163       (arg1)->GenerateControlPoints(arg2);
38164     } catch (std::out_of_range& e) {
38165       {
38166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38167       };
38168     } catch (std::exception& e) {
38169       {
38170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38175       };
38176     }
38177   }
38178 }
38179
38180
38181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38182   Dali::Path *arg1 = (Dali::Path *) 0 ;
38183   float arg2 ;
38184   Dali::Vector3 *arg3 = 0 ;
38185   Dali::Vector3 *arg4 = 0 ;
38186
38187   arg1 = (Dali::Path *)jarg1;
38188   arg2 = (float)jarg2;
38189   arg3 = (Dali::Vector3 *)jarg3;
38190   if (!arg3) {
38191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38192     return ;
38193   }
38194   arg4 = (Dali::Vector3 *)jarg4;
38195   if (!arg4) {
38196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38197     return ;
38198   }
38199   {
38200     try {
38201       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38202     } catch (std::out_of_range& e) {
38203       {
38204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38205       };
38206     } catch (std::exception& e) {
38207       {
38208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38209       };
38210     } catch (...) {
38211       {
38212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38213       };
38214     }
38215   }
38216 }
38217
38218
38219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38220   void * jresult ;
38221   Dali::Path *arg1 = (Dali::Path *) 0 ;
38222   size_t arg2 ;
38223   Dali::Vector3 *result = 0 ;
38224
38225   arg1 = (Dali::Path *)jarg1;
38226   arg2 = (size_t)jarg2;
38227   {
38228     try {
38229       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38230     } catch (std::out_of_range& e) {
38231       {
38232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38233       };
38234     } catch (std::exception& e) {
38235       {
38236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (...) {
38239       {
38240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38241       };
38242     }
38243   }
38244   jresult = (void *)result;
38245   return jresult;
38246 }
38247
38248
38249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38250   void * jresult ;
38251   Dali::Path *arg1 = (Dali::Path *) 0 ;
38252   size_t arg2 ;
38253   Dali::Vector3 *result = 0 ;
38254
38255   arg1 = (Dali::Path *)jarg1;
38256   arg2 = (size_t)jarg2;
38257   {
38258     try {
38259       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38260     } catch (std::out_of_range& e) {
38261       {
38262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38263       };
38264     } catch (std::exception& e) {
38265       {
38266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38267       };
38268     } catch (...) {
38269       {
38270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38271       };
38272     }
38273   }
38274   jresult = (void *)result;
38275   return jresult;
38276 }
38277
38278
38279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38280   unsigned long jresult ;
38281   Dali::Path *arg1 = (Dali::Path *) 0 ;
38282   size_t result;
38283
38284   arg1 = (Dali::Path *)jarg1;
38285   {
38286     try {
38287       result = ((Dali::Path const *)arg1)->GetPointCount();
38288     } catch (std::out_of_range& e) {
38289       {
38290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38291       };
38292     } catch (std::exception& e) {
38293       {
38294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38295       };
38296     } catch (...) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38299       };
38300     }
38301   }
38302   jresult = (unsigned long)result;
38303   return jresult;
38304 }
38305
38306
38307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38308   void * jresult ;
38309   float arg1 ;
38310   Dali::TimePeriod *result = 0 ;
38311
38312   arg1 = (float)jarg1;
38313   {
38314     try {
38315       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38316     } catch (std::out_of_range& e) {
38317       {
38318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38319       };
38320     } catch (std::exception& e) {
38321       {
38322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38323       };
38324     } catch (...) {
38325       {
38326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38327       };
38328     }
38329   }
38330   jresult = (void *)result;
38331   return jresult;
38332 }
38333
38334
38335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38336   void * jresult ;
38337   float arg1 ;
38338   float arg2 ;
38339   Dali::TimePeriod *result = 0 ;
38340
38341   arg1 = (float)jarg1;
38342   arg2 = (float)jarg2;
38343   {
38344     try {
38345       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38346     } catch (std::out_of_range& e) {
38347       {
38348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38349       };
38350     } catch (std::exception& e) {
38351       {
38352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38357       };
38358     }
38359   }
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38366   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38367
38368   arg1 = (Dali::TimePeriod *)jarg1;
38369   {
38370     try {
38371       delete arg1;
38372     } catch (std::out_of_range& e) {
38373       {
38374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38375       };
38376     } catch (std::exception& e) {
38377       {
38378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38383       };
38384     }
38385   }
38386 }
38387
38388
38389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38390   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38391   float arg2 ;
38392
38393   arg1 = (Dali::TimePeriod *)jarg1;
38394   arg2 = (float)jarg2;
38395   if (arg1) (arg1)->delaySeconds = arg2;
38396 }
38397
38398
38399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38400   float jresult ;
38401   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38402   float result;
38403
38404   arg1 = (Dali::TimePeriod *)jarg1;
38405   result = (float) ((arg1)->delaySeconds);
38406   jresult = result;
38407   return jresult;
38408 }
38409
38410
38411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38412   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38413   float arg2 ;
38414
38415   arg1 = (Dali::TimePeriod *)jarg1;
38416   arg2 = (float)jarg2;
38417   if (arg1) (arg1)->durationSeconds = arg2;
38418 }
38419
38420
38421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38422   float jresult ;
38423   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38424   float result;
38425
38426   arg1 = (Dali::TimePeriod *)jarg1;
38427   result = (float) ((arg1)->durationSeconds);
38428   jresult = result;
38429   return jresult;
38430 }
38431
38432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38433   int jresult ;
38434   int result;
38435
38436   result = (int)Dali::LinearConstrainer::Property::VALUE;
38437   jresult = (int)result;
38438   return jresult;
38439 }
38440
38441
38442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38443   int jresult ;
38444   int result;
38445
38446   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38447   jresult = (int)result;
38448   return jresult;
38449 }
38450
38451
38452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38453   void * jresult ;
38454   Dali::LinearConstrainer::Property *result = 0 ;
38455
38456   {
38457     try {
38458       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38459     } catch (std::out_of_range& e) {
38460       {
38461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38462       };
38463     } catch (std::exception& e) {
38464       {
38465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38466       };
38467     } catch (...) {
38468       {
38469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38470       };
38471     }
38472   }
38473   jresult = (void *)result;
38474   return jresult;
38475 }
38476
38477
38478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38479   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38480
38481   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38482   {
38483     try {
38484       delete arg1;
38485     } catch (std::out_of_range& e) {
38486       {
38487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38488       };
38489     } catch (std::exception& e) {
38490       {
38491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38492       };
38493     } catch (...) {
38494       {
38495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38496       };
38497     }
38498   }
38499 }
38500
38501
38502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38503   void * jresult ;
38504   Dali::LinearConstrainer result;
38505
38506   {
38507     try {
38508       result = Dali::LinearConstrainer::New();
38509     } catch (std::out_of_range& e) {
38510       {
38511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38512       };
38513     } catch (std::exception& e) {
38514       {
38515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38516       };
38517     } catch (...) {
38518       {
38519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38520       };
38521     }
38522   }
38523   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38524   return jresult;
38525 }
38526
38527
38528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38529   void * jresult ;
38530   Dali::BaseHandle arg1 ;
38531   Dali::BaseHandle *argp1 ;
38532   Dali::LinearConstrainer result;
38533
38534   argp1 = (Dali::BaseHandle *)jarg1;
38535   if (!argp1) {
38536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38537     return 0;
38538   }
38539   arg1 = *argp1;
38540   {
38541     try {
38542       result = Dali::LinearConstrainer::DownCast(arg1);
38543     } catch (std::out_of_range& e) {
38544       {
38545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (std::exception& e) {
38548       {
38549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38558   return jresult;
38559 }
38560
38561
38562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38563   void * jresult ;
38564   Dali::LinearConstrainer *result = 0 ;
38565
38566   {
38567     try {
38568       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583   jresult = (void *)result;
38584   return jresult;
38585 }
38586
38587
38588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38589   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38590
38591   arg1 = (Dali::LinearConstrainer *)jarg1;
38592   {
38593     try {
38594       delete arg1;
38595     } catch (std::out_of_range& e) {
38596       {
38597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38598       };
38599     } catch (std::exception& e) {
38600       {
38601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38602       };
38603     } catch (...) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38606       };
38607     }
38608   }
38609 }
38610
38611
38612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38613   void * jresult ;
38614   Dali::LinearConstrainer *arg1 = 0 ;
38615   Dali::LinearConstrainer *result = 0 ;
38616
38617   arg1 = (Dali::LinearConstrainer *)jarg1;
38618   if (!arg1) {
38619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38620     return 0;
38621   }
38622   {
38623     try {
38624       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38625     } catch (std::out_of_range& e) {
38626       {
38627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38628       };
38629     } catch (std::exception& e) {
38630       {
38631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (...) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38636       };
38637     }
38638   }
38639   jresult = (void *)result;
38640   return jresult;
38641 }
38642
38643
38644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38645   void * jresult ;
38646   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38647   Dali::LinearConstrainer *arg2 = 0 ;
38648   Dali::LinearConstrainer *result = 0 ;
38649
38650   arg1 = (Dali::LinearConstrainer *)jarg1;
38651   arg2 = (Dali::LinearConstrainer *)jarg2;
38652   if (!arg2) {
38653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38654     return 0;
38655   }
38656   {
38657     try {
38658       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38659     } catch (std::out_of_range& e) {
38660       {
38661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38662       };
38663     } catch (std::exception& e) {
38664       {
38665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (...) {
38668       {
38669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38670       };
38671     }
38672   }
38673   jresult = (void *)result;
38674   return jresult;
38675 }
38676
38677
38678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38679   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38680   SwigValueWrapper< Dali::Property > arg2 ;
38681   SwigValueWrapper< Dali::Property > arg3 ;
38682   Dali::Vector2 *arg4 = 0 ;
38683   Dali::Vector2 *arg5 = 0 ;
38684   Dali::Property *argp2 ;
38685   Dali::Property *argp3 ;
38686
38687   arg1 = (Dali::LinearConstrainer *)jarg1;
38688   argp2 = (Dali::Property *)jarg2;
38689   if (!argp2) {
38690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38691     return ;
38692   }
38693   arg2 = *argp2;
38694   argp3 = (Dali::Property *)jarg3;
38695   if (!argp3) {
38696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38697     return ;
38698   }
38699   arg3 = *argp3;
38700   arg4 = (Dali::Vector2 *)jarg4;
38701   if (!arg4) {
38702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38703     return ;
38704   }
38705   arg5 = (Dali::Vector2 *)jarg5;
38706   if (!arg5) {
38707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38708     return ;
38709   }
38710   {
38711     try {
38712       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38713     } catch (std::out_of_range& e) {
38714       {
38715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38716       };
38717     } catch (std::exception& e) {
38718       {
38719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38720       };
38721     } catch (...) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38724       };
38725     }
38726   }
38727 }
38728
38729
38730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38731   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38732   SwigValueWrapper< Dali::Property > arg2 ;
38733   SwigValueWrapper< Dali::Property > arg3 ;
38734   Dali::Vector2 *arg4 = 0 ;
38735   Dali::Property *argp2 ;
38736   Dali::Property *argp3 ;
38737
38738   arg1 = (Dali::LinearConstrainer *)jarg1;
38739   argp2 = (Dali::Property *)jarg2;
38740   if (!argp2) {
38741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38742     return ;
38743   }
38744   arg2 = *argp2;
38745   argp3 = (Dali::Property *)jarg3;
38746   if (!argp3) {
38747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38748     return ;
38749   }
38750   arg3 = *argp3;
38751   arg4 = (Dali::Vector2 *)jarg4;
38752   if (!arg4) {
38753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38754     return ;
38755   }
38756   {
38757     try {
38758       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38759     } catch (std::out_of_range& e) {
38760       {
38761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38762       };
38763     } catch (std::exception& e) {
38764       {
38765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38766       };
38767     } catch (...) {
38768       {
38769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38770       };
38771     }
38772   }
38773 }
38774
38775
38776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38777   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38778   Dali::Handle *arg2 = 0 ;
38779
38780   arg1 = (Dali::LinearConstrainer *)jarg1;
38781   arg2 = (Dali::Handle *)jarg2;
38782   if (!arg2) {
38783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38784     return ;
38785   }
38786   {
38787     try {
38788       (arg1)->Remove(*arg2);
38789     } catch (std::out_of_range& e) {
38790       {
38791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38792       };
38793     } catch (std::exception& e) {
38794       {
38795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38796       };
38797     } catch (...) {
38798       {
38799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38800       };
38801     }
38802   }
38803 }
38804
38805
38806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38807   int jresult ;
38808   int result;
38809
38810   result = (int)Dali::PathConstrainer::Property::FORWARD;
38811   jresult = (int)result;
38812   return jresult;
38813 }
38814
38815
38816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38817   int jresult ;
38818   int result;
38819
38820   result = (int)Dali::PathConstrainer::Property::POINTS;
38821   jresult = (int)result;
38822   return jresult;
38823 }
38824
38825
38826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38827   int jresult ;
38828   int result;
38829
38830   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38831   jresult = (int)result;
38832   return jresult;
38833 }
38834
38835
38836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38837   void * jresult ;
38838   Dali::PathConstrainer::Property *result = 0 ;
38839
38840   {
38841     try {
38842       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38843     } catch (std::out_of_range& e) {
38844       {
38845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (std::exception& e) {
38848       {
38849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857   jresult = (void *)result;
38858   return jresult;
38859 }
38860
38861
38862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38863   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38864
38865   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38866   {
38867     try {
38868       delete arg1;
38869     } catch (std::out_of_range& e) {
38870       {
38871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38872       };
38873     } catch (std::exception& e) {
38874       {
38875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38876       };
38877     } catch (...) {
38878       {
38879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38880       };
38881     }
38882   }
38883 }
38884
38885
38886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38887   void * jresult ;
38888   Dali::PathConstrainer result;
38889
38890   {
38891     try {
38892       result = Dali::PathConstrainer::New();
38893     } catch (std::out_of_range& e) {
38894       {
38895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38896       };
38897     } catch (std::exception& e) {
38898       {
38899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (...) {
38902       {
38903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38904       };
38905     }
38906   }
38907   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38908   return jresult;
38909 }
38910
38911
38912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38913   void * jresult ;
38914   Dali::BaseHandle arg1 ;
38915   Dali::BaseHandle *argp1 ;
38916   Dali::PathConstrainer result;
38917
38918   argp1 = (Dali::BaseHandle *)jarg1;
38919   if (!argp1) {
38920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38921     return 0;
38922   }
38923   arg1 = *argp1;
38924   {
38925     try {
38926       result = Dali::PathConstrainer::DownCast(arg1);
38927     } catch (std::out_of_range& e) {
38928       {
38929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38930       };
38931     } catch (std::exception& e) {
38932       {
38933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38934       };
38935     } catch (...) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38938       };
38939     }
38940   }
38941   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38942   return jresult;
38943 }
38944
38945
38946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38947   void * jresult ;
38948   Dali::PathConstrainer *result = 0 ;
38949
38950   {
38951     try {
38952       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38953     } catch (std::out_of_range& e) {
38954       {
38955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38956       };
38957     } catch (std::exception& e) {
38958       {
38959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38960       };
38961     } catch (...) {
38962       {
38963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38964       };
38965     }
38966   }
38967   jresult = (void *)result;
38968   return jresult;
38969 }
38970
38971
38972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38973   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38974
38975   arg1 = (Dali::PathConstrainer *)jarg1;
38976   {
38977     try {
38978       delete arg1;
38979     } catch (std::out_of_range& e) {
38980       {
38981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38982       };
38983     } catch (std::exception& e) {
38984       {
38985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38990       };
38991     }
38992   }
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38997   void * jresult ;
38998   Dali::PathConstrainer *arg1 = 0 ;
38999   Dali::PathConstrainer *result = 0 ;
39000
39001   arg1 = (Dali::PathConstrainer *)jarg1;
39002   if (!arg1) {
39003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39004     return 0;
39005   }
39006   {
39007     try {
39008       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023   jresult = (void *)result;
39024   return jresult;
39025 }
39026
39027
39028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39029   void * jresult ;
39030   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39031   Dali::PathConstrainer *arg2 = 0 ;
39032   Dali::PathConstrainer *result = 0 ;
39033
39034   arg1 = (Dali::PathConstrainer *)jarg1;
39035   arg2 = (Dali::PathConstrainer *)jarg2;
39036   if (!arg2) {
39037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39038     return 0;
39039   }
39040   {
39041     try {
39042       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39043     } catch (std::out_of_range& e) {
39044       {
39045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39046       };
39047     } catch (std::exception& e) {
39048       {
39049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39050       };
39051     } catch (...) {
39052       {
39053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39054       };
39055     }
39056   }
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39063   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39064   SwigValueWrapper< Dali::Property > arg2 ;
39065   SwigValueWrapper< Dali::Property > arg3 ;
39066   Dali::Vector2 *arg4 = 0 ;
39067   Dali::Vector2 *arg5 = 0 ;
39068   Dali::Property *argp2 ;
39069   Dali::Property *argp3 ;
39070
39071   arg1 = (Dali::PathConstrainer *)jarg1;
39072   argp2 = (Dali::Property *)jarg2;
39073   if (!argp2) {
39074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39075     return ;
39076   }
39077   arg2 = *argp2;
39078   argp3 = (Dali::Property *)jarg3;
39079   if (!argp3) {
39080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39081     return ;
39082   }
39083   arg3 = *argp3;
39084   arg4 = (Dali::Vector2 *)jarg4;
39085   if (!arg4) {
39086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39087     return ;
39088   }
39089   arg5 = (Dali::Vector2 *)jarg5;
39090   if (!arg5) {
39091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39092     return ;
39093   }
39094   {
39095     try {
39096       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39097     } catch (std::out_of_range& e) {
39098       {
39099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39100       };
39101     } catch (std::exception& e) {
39102       {
39103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39104       };
39105     } catch (...) {
39106       {
39107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39108       };
39109     }
39110   }
39111 }
39112
39113
39114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39115   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39116   SwigValueWrapper< Dali::Property > arg2 ;
39117   SwigValueWrapper< Dali::Property > arg3 ;
39118   Dali::Vector2 *arg4 = 0 ;
39119   Dali::Property *argp2 ;
39120   Dali::Property *argp3 ;
39121
39122   arg1 = (Dali::PathConstrainer *)jarg1;
39123   argp2 = (Dali::Property *)jarg2;
39124   if (!argp2) {
39125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39126     return ;
39127   }
39128   arg2 = *argp2;
39129   argp3 = (Dali::Property *)jarg3;
39130   if (!argp3) {
39131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39132     return ;
39133   }
39134   arg3 = *argp3;
39135   arg4 = (Dali::Vector2 *)jarg4;
39136   if (!arg4) {
39137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39138     return ;
39139   }
39140   {
39141     try {
39142       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39143     } catch (std::out_of_range& e) {
39144       {
39145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (std::exception& e) {
39148       {
39149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39154       };
39155     }
39156   }
39157 }
39158
39159
39160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39161   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39162   Dali::Handle *arg2 = 0 ;
39163
39164   arg1 = (Dali::PathConstrainer *)jarg1;
39165   arg2 = (Dali::Handle *)jarg2;
39166   if (!arg2) {
39167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39168     return ;
39169   }
39170   {
39171     try {
39172       (arg1)->Remove(*arg2);
39173     } catch (std::out_of_range& e) {
39174       {
39175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39176       };
39177     } catch (std::exception& e) {
39178       {
39179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39180       };
39181     } catch (...) {
39182       {
39183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39184       };
39185     }
39186   }
39187 }
39188
39189
39190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39191   int jresult ;
39192   Dali::FittingMode::Type result;
39193
39194   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39195   jresult = (int)result;
39196   return jresult;
39197 }
39198
39199
39200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39201   int jresult ;
39202   Dali::SamplingMode::Type result;
39203
39204   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39205   jresult = (int)result;
39206   return jresult;
39207 }
39208
39209
39210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39211   void * jresult ;
39212   Dali::BufferImage *result = 0 ;
39213
39214   {
39215     try {
39216       result = (Dali::BufferImage *)new Dali::BufferImage();
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (...) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39228       };
39229     }
39230   }
39231   jresult = (void *)result;
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39237   void * jresult ;
39238   unsigned int arg1 ;
39239   unsigned int arg2 ;
39240   Dali::Pixel::Format arg3 ;
39241   Dali::BufferImage result;
39242
39243   arg1 = (unsigned int)jarg1;
39244   arg2 = (unsigned int)jarg2;
39245   arg3 = (Dali::Pixel::Format)jarg3;
39246   {
39247     try {
39248       result = Dali::BufferImage::New(arg1,arg2,arg3);
39249     } catch (std::out_of_range& e) {
39250       {
39251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39252       };
39253     } catch (std::exception& e) {
39254       {
39255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39256       };
39257     } catch (...) {
39258       {
39259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39260       };
39261     }
39262   }
39263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39264   return jresult;
39265 }
39266
39267
39268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39269   void * jresult ;
39270   unsigned int arg1 ;
39271   unsigned int arg2 ;
39272   Dali::BufferImage result;
39273
39274   arg1 = (unsigned int)jarg1;
39275   arg2 = (unsigned int)jarg2;
39276   {
39277     try {
39278       result = Dali::BufferImage::New(arg1,arg2);
39279     } catch (std::out_of_range& e) {
39280       {
39281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39282       };
39283     } catch (std::exception& e) {
39284       {
39285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39286       };
39287     } catch (...) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39290       };
39291     }
39292   }
39293   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39294   return jresult;
39295 }
39296
39297
39298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39299   void * jresult ;
39300   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39301   unsigned int arg2 ;
39302   unsigned int arg3 ;
39303   Dali::Pixel::Format arg4 ;
39304   unsigned int arg5 ;
39305   Dali::BufferImage result;
39306
39307   arg1 = jarg1;
39308   arg2 = (unsigned int)jarg2;
39309   arg3 = (unsigned int)jarg3;
39310   arg4 = (Dali::Pixel::Format)jarg4;
39311   arg5 = (unsigned int)jarg5;
39312   {
39313     try {
39314       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39315     } catch (std::out_of_range& e) {
39316       {
39317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39318       };
39319     } catch (std::exception& e) {
39320       {
39321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (...) {
39324       {
39325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39326       };
39327     }
39328   }
39329   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39330
39331
39332   return jresult;
39333 }
39334
39335
39336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39337   void * jresult ;
39338   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39339   unsigned int arg2 ;
39340   unsigned int arg3 ;
39341   Dali::Pixel::Format arg4 ;
39342   Dali::BufferImage result;
39343
39344   arg1 = jarg1;
39345   arg2 = (unsigned int)jarg2;
39346   arg3 = (unsigned int)jarg3;
39347   arg4 = (Dali::Pixel::Format)jarg4;
39348   {
39349     try {
39350       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39351     } catch (std::out_of_range& e) {
39352       {
39353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39354       };
39355     } catch (std::exception& e) {
39356       {
39357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39358       };
39359     } catch (...) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39362       };
39363     }
39364   }
39365   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39366
39367
39368   return jresult;
39369 }
39370
39371
39372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39373   void * jresult ;
39374   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39375   unsigned int arg2 ;
39376   unsigned int arg3 ;
39377   Dali::BufferImage result;
39378
39379   arg1 = jarg1;
39380   arg2 = (unsigned int)jarg2;
39381   arg3 = (unsigned int)jarg3;
39382   {
39383     try {
39384       result = Dali::BufferImage::New(arg1,arg2,arg3);
39385     } catch (std::out_of_range& e) {
39386       {
39387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39388       };
39389     } catch (std::exception& e) {
39390       {
39391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39392       };
39393     } catch (...) {
39394       {
39395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39396       };
39397     }
39398   }
39399   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39400
39401
39402   return jresult;
39403 }
39404
39405
39406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39407   void * jresult ;
39408   Dali::BaseHandle arg1 ;
39409   Dali::BaseHandle *argp1 ;
39410   Dali::BufferImage result;
39411
39412   argp1 = (Dali::BaseHandle *)jarg1;
39413   if (!argp1) {
39414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39415     return 0;
39416   }
39417   arg1 = *argp1;
39418   {
39419     try {
39420       result = Dali::BufferImage::DownCast(arg1);
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39432       };
39433     }
39434   }
39435   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39436   return jresult;
39437 }
39438
39439
39440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39441   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39442
39443   arg1 = (Dali::BufferImage *)jarg1;
39444   {
39445     try {
39446       delete arg1;
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39454       };
39455     } catch (...) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39458       };
39459     }
39460   }
39461 }
39462
39463
39464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39465   void * jresult ;
39466   Dali::BufferImage *arg1 = 0 ;
39467   Dali::BufferImage *result = 0 ;
39468
39469   arg1 = (Dali::BufferImage *)jarg1;
39470   if (!arg1) {
39471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39472     return 0;
39473   }
39474   {
39475     try {
39476       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39477     } catch (std::out_of_range& e) {
39478       {
39479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39480       };
39481     } catch (std::exception& e) {
39482       {
39483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39484       };
39485     } catch (...) {
39486       {
39487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39488       };
39489     }
39490   }
39491   jresult = (void *)result;
39492   return jresult;
39493 }
39494
39495
39496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39497   void * jresult ;
39498   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39499   Dali::BufferImage *arg2 = 0 ;
39500   Dali::BufferImage *result = 0 ;
39501
39502   arg1 = (Dali::BufferImage *)jarg1;
39503   arg2 = (Dali::BufferImage *)jarg2;
39504   if (!arg2) {
39505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39506     return 0;
39507   }
39508   {
39509     try {
39510       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39511     } catch (std::out_of_range& e) {
39512       {
39513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39514       };
39515     } catch (std::exception& e) {
39516       {
39517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39518       };
39519     } catch (...) {
39520       {
39521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39522       };
39523     }
39524   }
39525   jresult = (void *)result;
39526   return jresult;
39527 }
39528
39529
39530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39531   void * jresult ;
39532   Dali::BufferImage result;
39533
39534   {
39535     try {
39536       result = Dali::BufferImage::WHITE();
39537     } catch (std::out_of_range& e) {
39538       {
39539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39540       };
39541     } catch (std::exception& e) {
39542       {
39543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39544       };
39545     } catch (...) {
39546       {
39547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39548       };
39549     }
39550   }
39551   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39552   return jresult;
39553 }
39554
39555
39556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39557   void * jresult ;
39558   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39559   Dali::PixelBuffer *result = 0 ;
39560
39561   arg1 = (Dali::BufferImage *)jarg1;
39562   {
39563     try {
39564       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39565     } catch (std::out_of_range& e) {
39566       {
39567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39568       };
39569     } catch (std::exception& e) {
39570       {
39571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39572       };
39573     } catch (...) {
39574       {
39575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39576       };
39577     }
39578   }
39579   jresult = (void *)result;
39580   return jresult;
39581 }
39582
39583
39584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39585   unsigned int jresult ;
39586   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39587   unsigned int result;
39588
39589   arg1 = (Dali::BufferImage *)jarg1;
39590   {
39591     try {
39592       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39593     } catch (std::out_of_range& e) {
39594       {
39595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39596       };
39597     } catch (std::exception& e) {
39598       {
39599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39600       };
39601     } catch (...) {
39602       {
39603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39604       };
39605     }
39606   }
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39613   unsigned int jresult ;
39614   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39615   unsigned int result;
39616
39617   arg1 = (Dali::BufferImage *)jarg1;
39618   {
39619     try {
39620       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39632       };
39633     }
39634   }
39635   jresult = result;
39636   return jresult;
39637 }
39638
39639
39640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39641   int jresult ;
39642   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39643   Dali::Pixel::Format result;
39644
39645   arg1 = (Dali::BufferImage *)jarg1;
39646   {
39647     try {
39648       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39649     } catch (std::out_of_range& e) {
39650       {
39651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39652       };
39653     } catch (std::exception& e) {
39654       {
39655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (...) {
39658       {
39659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39660       };
39661     }
39662   }
39663   jresult = (int)result;
39664   return jresult;
39665 }
39666
39667
39668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39669   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39670
39671   arg1 = (Dali::BufferImage *)jarg1;
39672   {
39673     try {
39674       (arg1)->Update();
39675     } catch (std::out_of_range& e) {
39676       {
39677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39678       };
39679     } catch (std::exception& e) {
39680       {
39681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39682       };
39683     } catch (...) {
39684       {
39685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39686       };
39687     }
39688   }
39689 }
39690
39691
39692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39693   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39694   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39695   Dali::RectArea *argp2 ;
39696
39697   arg1 = (Dali::BufferImage *)jarg1;
39698   argp2 = (Dali::RectArea *)jarg2;
39699   if (!argp2) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39701     return ;
39702   }
39703   arg2 = *argp2;
39704   {
39705     try {
39706       (arg1)->Update(arg2);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39725   unsigned int jresult ;
39726   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39727   bool result;
39728
39729   arg1 = (Dali::BufferImage *)jarg1;
39730   {
39731     try {
39732       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39733     } catch (std::out_of_range& e) {
39734       {
39735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39736       };
39737     } catch (std::exception& e) {
39738       {
39739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (...) {
39742       {
39743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39744       };
39745     }
39746   }
39747   jresult = result;
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39753   void * jresult ;
39754   Dali::EncodedBufferImage *result = 0 ;
39755
39756   {
39757     try {
39758       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39759     } catch (std::out_of_range& e) {
39760       {
39761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39762       };
39763     } catch (std::exception& e) {
39764       {
39765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39766       };
39767     } catch (...) {
39768       {
39769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39770       };
39771     }
39772   }
39773   jresult = (void *)result;
39774   return jresult;
39775 }
39776
39777
39778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39779   void * jresult ;
39780   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39781   std::size_t arg2 ;
39782   Dali::EncodedBufferImage result;
39783
39784   arg1 = (uint8_t *)jarg1;
39785   arg2 = (std::size_t)jarg2;
39786   {
39787     try {
39788       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39789     } catch (std::out_of_range& e) {
39790       {
39791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39792       };
39793     } catch (std::exception& e) {
39794       {
39795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39796       };
39797     } catch (...) {
39798       {
39799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39800       };
39801     }
39802   }
39803   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39804   return jresult;
39805 }
39806
39807
39808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39809   void * jresult ;
39810   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39811   std::size_t arg2 ;
39812   Dali::ImageDimensions arg3 ;
39813   Dali::FittingMode::Type arg4 ;
39814   Dali::SamplingMode::Type arg5 ;
39815   bool arg6 ;
39816   Dali::ImageDimensions *argp3 ;
39817   Dali::EncodedBufferImage result;
39818
39819   arg1 = (uint8_t *)jarg1;
39820   arg2 = (std::size_t)jarg2;
39821   argp3 = (Dali::ImageDimensions *)jarg3;
39822   if (!argp3) {
39823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39824     return 0;
39825   }
39826   arg3 = *argp3;
39827   arg4 = (Dali::FittingMode::Type)jarg4;
39828   arg5 = (Dali::SamplingMode::Type)jarg5;
39829   arg6 = jarg6 ? true : false;
39830   {
39831     try {
39832       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39833     } catch (std::out_of_range& e) {
39834       {
39835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39836       };
39837     } catch (std::exception& e) {
39838       {
39839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (...) {
39842       {
39843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39844       };
39845     }
39846   }
39847   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39848   return jresult;
39849 }
39850
39851
39852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39853   void * jresult ;
39854   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39855   std::size_t arg2 ;
39856   Dali::ImageDimensions arg3 ;
39857   Dali::FittingMode::Type arg4 ;
39858   Dali::SamplingMode::Type arg5 ;
39859   Dali::ImageDimensions *argp3 ;
39860   Dali::EncodedBufferImage result;
39861
39862   arg1 = (uint8_t *)jarg1;
39863   arg2 = (std::size_t)jarg2;
39864   argp3 = (Dali::ImageDimensions *)jarg3;
39865   if (!argp3) {
39866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39867     return 0;
39868   }
39869   arg3 = *argp3;
39870   arg4 = (Dali::FittingMode::Type)jarg4;
39871   arg5 = (Dali::SamplingMode::Type)jarg5;
39872   {
39873     try {
39874       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39875     } catch (std::out_of_range& e) {
39876       {
39877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39878       };
39879     } catch (std::exception& e) {
39880       {
39881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39882       };
39883     } catch (...) {
39884       {
39885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39886       };
39887     }
39888   }
39889   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39895   void * jresult ;
39896   Dali::BaseHandle arg1 ;
39897   Dali::BaseHandle *argp1 ;
39898   Dali::EncodedBufferImage result;
39899
39900   argp1 = (Dali::BaseHandle *)jarg1;
39901   if (!argp1) {
39902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39903     return 0;
39904   }
39905   arg1 = *argp1;
39906   {
39907     try {
39908       result = Dali::EncodedBufferImage::DownCast(arg1);
39909     } catch (std::out_of_range& e) {
39910       {
39911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39912       };
39913     } catch (std::exception& e) {
39914       {
39915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39916       };
39917     } catch (...) {
39918       {
39919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39920       };
39921     }
39922   }
39923   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39924   return jresult;
39925 }
39926
39927
39928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39929   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39930
39931   arg1 = (Dali::EncodedBufferImage *)jarg1;
39932   {
39933     try {
39934       delete arg1;
39935     } catch (std::out_of_range& e) {
39936       {
39937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39938       };
39939     } catch (std::exception& e) {
39940       {
39941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39942       };
39943     } catch (...) {
39944       {
39945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39946       };
39947     }
39948   }
39949 }
39950
39951
39952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39953   void * jresult ;
39954   Dali::EncodedBufferImage *arg1 = 0 ;
39955   Dali::EncodedBufferImage *result = 0 ;
39956
39957   arg1 = (Dali::EncodedBufferImage *)jarg1;
39958   if (!arg1) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39960     return 0;
39961   }
39962   {
39963     try {
39964       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39965     } catch (std::out_of_range& e) {
39966       {
39967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (std::exception& e) {
39970       {
39971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39972       };
39973     } catch (...) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39976       };
39977     }
39978   }
39979   jresult = (void *)result;
39980   return jresult;
39981 }
39982
39983
39984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39985   void * jresult ;
39986   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39987   Dali::EncodedBufferImage *arg2 = 0 ;
39988   Dali::EncodedBufferImage *result = 0 ;
39989
39990   arg1 = (Dali::EncodedBufferImage *)jarg1;
39991   arg2 = (Dali::EncodedBufferImage *)jarg2;
39992   if (!arg2) {
39993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39994     return 0;
39995   }
39996   {
39997     try {
39998       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39999     } catch (std::out_of_range& e) {
40000       {
40001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40002       };
40003     } catch (std::exception& e) {
40004       {
40005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40006       };
40007     } catch (...) {
40008       {
40009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40010       };
40011     }
40012   }
40013   jresult = (void *)result;
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40019   void * jresult ;
40020   Dali::NativeImage *result = 0 ;
40021
40022   {
40023     try {
40024       result = (Dali::NativeImage *)new Dali::NativeImage();
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40032       };
40033     } catch (...) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40036       };
40037     }
40038   }
40039   jresult = (void *)result;
40040   return jresult;
40041 }
40042
40043
40044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40045   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40046
40047   arg1 = (Dali::NativeImage *)jarg1;
40048   {
40049     try {
40050       delete arg1;
40051     } catch (std::out_of_range& e) {
40052       {
40053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40054       };
40055     } catch (std::exception& e) {
40056       {
40057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40058       };
40059     } catch (...) {
40060       {
40061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40062       };
40063     }
40064   }
40065 }
40066
40067
40068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40069   void * jresult ;
40070   Dali::NativeImage *arg1 = 0 ;
40071   Dali::NativeImage *result = 0 ;
40072
40073   arg1 = (Dali::NativeImage *)jarg1;
40074   if (!arg1) {
40075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40076     return 0;
40077   }
40078   {
40079     try {
40080       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40081     } catch (std::out_of_range& e) {
40082       {
40083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40084       };
40085     } catch (std::exception& e) {
40086       {
40087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40088       };
40089     } catch (...) {
40090       {
40091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40092       };
40093     }
40094   }
40095   jresult = (void *)result;
40096   return jresult;
40097 }
40098
40099
40100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40101   void * jresult ;
40102   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40103   Dali::NativeImage *arg2 = 0 ;
40104   Dali::NativeImage *result = 0 ;
40105
40106   arg1 = (Dali::NativeImage *)jarg1;
40107   arg2 = (Dali::NativeImage *)jarg2;
40108   if (!arg2) {
40109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40110     return 0;
40111   }
40112   {
40113     try {
40114       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (...) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40126       };
40127     }
40128   }
40129   jresult = (void *)result;
40130   return jresult;
40131 }
40132
40133
40134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40135   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40136
40137   arg1 = (Dali::NativeImage *)jarg1;
40138   {
40139     try {
40140       (arg1)->CreateGlTexture();
40141     } catch (std::out_of_range& e) {
40142       {
40143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40144       };
40145     } catch (std::exception& e) {
40146       {
40147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40148       };
40149     } catch (...) {
40150       {
40151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40152       };
40153     }
40154   }
40155 }
40156
40157
40158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40159   void * jresult ;
40160   NativeImageInterface *arg1 = 0 ;
40161   Dali::NativeImage result;
40162
40163   arg1 = (NativeImageInterface *)jarg1;
40164   if (!arg1) {
40165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40166     return 0;
40167   }
40168   {
40169     try {
40170       result = Dali::NativeImage::New(*arg1);
40171     } catch (std::out_of_range& e) {
40172       {
40173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40174       };
40175     } catch (std::exception& e) {
40176       {
40177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40178       };
40179     } catch (...) {
40180       {
40181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40182       };
40183     }
40184   }
40185   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40186   return jresult;
40187 }
40188
40189
40190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40191   void * jresult ;
40192   Dali::BaseHandle arg1 ;
40193   Dali::BaseHandle *argp1 ;
40194   Dali::NativeImage result;
40195
40196   argp1 = (Dali::BaseHandle *)jarg1;
40197   if (!argp1) {
40198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40199     return 0;
40200   }
40201   arg1 = *argp1;
40202   {
40203     try {
40204       result = Dali::NativeImage::DownCast(arg1);
40205     } catch (std::out_of_range& e) {
40206       {
40207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40208       };
40209     } catch (std::exception& e) {
40210       {
40211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40212       };
40213     } catch (...) {
40214       {
40215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40216       };
40217     }
40218   }
40219   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40220   return jresult;
40221 }
40222
40223
40224 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40225   char * jresult ;
40226   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40227   char *result = 0 ;
40228
40229   arg1 = (Dali::NativeImage *)jarg1;
40230   {
40231     try {
40232       result = (char *)(arg1)->GetCustomFragmentPreFix();
40233     } catch (std::out_of_range& e) {
40234       {
40235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40236       };
40237     } catch (std::exception& e) {
40238       {
40239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40240       };
40241     } catch (...) {
40242       {
40243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40244       };
40245     }
40246   }
40247   jresult = SWIG_csharp_string_callback((const char *)result);
40248   return jresult;
40249 }
40250
40251
40252 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40253   char * jresult ;
40254   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40255   char *result = 0 ;
40256
40257   arg1 = (Dali::NativeImage *)jarg1;
40258   {
40259     try {
40260       result = (char *)(arg1)->GetCustomSamplerTypename();
40261     } catch (std::out_of_range& e) {
40262       {
40263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40264       };
40265     } catch (std::exception& e) {
40266       {
40267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40272       };
40273     }
40274   }
40275   jresult = SWIG_csharp_string_callback((const char *)result);
40276   return jresult;
40277 }
40278
40279
40280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40281   unsigned int jresult ;
40282   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40283   bool result;
40284
40285   arg1 = (Dali::NativeImageInterface *)jarg1;
40286   {
40287     try {
40288       result = (bool)(arg1)->GlExtensionCreate();
40289     } catch (std::out_of_range& e) {
40290       {
40291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40292       };
40293     } catch (std::exception& e) {
40294       {
40295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40296       };
40297     } catch (...) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40300       };
40301     }
40302   }
40303   jresult = result;
40304   return jresult;
40305 }
40306
40307
40308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40309   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40310
40311   arg1 = (Dali::NativeImageInterface *)jarg1;
40312   {
40313     try {
40314       (arg1)->GlExtensionDestroy();
40315     } catch (std::out_of_range& e) {
40316       {
40317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40318       };
40319     } catch (std::exception& e) {
40320       {
40321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40322       };
40323     } catch (...) {
40324       {
40325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40326       };
40327     }
40328   }
40329 }
40330
40331
40332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40333   unsigned int jresult ;
40334   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40335   unsigned int result;
40336
40337   arg1 = (Dali::NativeImageInterface *)jarg1;
40338   {
40339     try {
40340       result = (unsigned int)(arg1)->TargetTexture();
40341     } catch (std::out_of_range& e) {
40342       {
40343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40344       };
40345     } catch (std::exception& e) {
40346       {
40347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40348       };
40349     } catch (...) {
40350       {
40351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40352       };
40353     }
40354   }
40355   jresult = result;
40356   return jresult;
40357 }
40358
40359
40360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40361   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40362
40363   arg1 = (Dali::NativeImageInterface *)jarg1;
40364   {
40365     try {
40366       (arg1)->PrepareTexture();
40367     } catch (std::out_of_range& e) {
40368       {
40369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40370       };
40371     } catch (std::exception& e) {
40372       {
40373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40374       };
40375     } catch (...) {
40376       {
40377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40378       };
40379     }
40380   }
40381 }
40382
40383
40384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40385   unsigned int jresult ;
40386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40387   unsigned int result;
40388
40389   arg1 = (Dali::NativeImageInterface *)jarg1;
40390   {
40391     try {
40392       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (...) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40404       };
40405     }
40406   }
40407   jresult = result;
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40413   unsigned int jresult ;
40414   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40415   unsigned int result;
40416
40417   arg1 = (Dali::NativeImageInterface *)jarg1;
40418   {
40419     try {
40420       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40421     } catch (std::out_of_range& e) {
40422       {
40423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40424       };
40425     } catch (std::exception& e) {
40426       {
40427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40428       };
40429     } catch (...) {
40430       {
40431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40432       };
40433     }
40434   }
40435   jresult = result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40441   unsigned int jresult ;
40442   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40443   bool result;
40444
40445   arg1 = (Dali::NativeImageInterface *)jarg1;
40446   {
40447     try {
40448       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40449     } catch (std::out_of_range& e) {
40450       {
40451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40452       };
40453     } catch (std::exception& e) {
40454       {
40455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40456       };
40457     } catch (...) {
40458       {
40459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40460       };
40461     }
40462   }
40463   jresult = result;
40464   return jresult;
40465 }
40466
40467
40468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40469   void * jresult ;
40470   std::string *arg1 = 0 ;
40471   Dali::ImageDimensions result;
40472
40473   if (!jarg1) {
40474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40475     return 0;
40476   }
40477   std::string arg1_str(jarg1);
40478   arg1 = &arg1_str;
40479   {
40480     try {
40481       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40482     } catch (std::out_of_range& e) {
40483       {
40484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40485       };
40486     } catch (std::exception& e) {
40487       {
40488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40489       };
40490     } catch (...) {
40491       {
40492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40493       };
40494     }
40495   }
40496   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40497
40498   //argout typemap for const std::string&
40499
40500   return jresult;
40501 }
40502
40503
40504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40505   void * jresult ;
40506   Dali::ResourceImage *result = 0 ;
40507
40508   {
40509     try {
40510       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40511     } catch (std::out_of_range& e) {
40512       {
40513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40514       };
40515     } catch (std::exception& e) {
40516       {
40517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40518       };
40519     } catch (...) {
40520       {
40521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40522       };
40523     }
40524   }
40525   jresult = (void *)result;
40526   return jresult;
40527 }
40528
40529
40530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40531   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40532
40533   arg1 = (Dali::ResourceImage *)jarg1;
40534   {
40535     try {
40536       delete arg1;
40537     } catch (std::out_of_range& e) {
40538       {
40539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40540       };
40541     } catch (std::exception& e) {
40542       {
40543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40544       };
40545     } catch (...) {
40546       {
40547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40548       };
40549     }
40550   }
40551 }
40552
40553
40554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40555   void * jresult ;
40556   Dali::ResourceImage *arg1 = 0 ;
40557   Dali::ResourceImage *result = 0 ;
40558
40559   arg1 = (Dali::ResourceImage *)jarg1;
40560   if (!arg1) {
40561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40562     return 0;
40563   }
40564   {
40565     try {
40566       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581   jresult = (void *)result;
40582   return jresult;
40583 }
40584
40585
40586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40587   void * jresult ;
40588   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40589   Dali::ResourceImage *arg2 = 0 ;
40590   Dali::ResourceImage *result = 0 ;
40591
40592   arg1 = (Dali::ResourceImage *)jarg1;
40593   arg2 = (Dali::ResourceImage *)jarg2;
40594   if (!arg2) {
40595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40596     return 0;
40597   }
40598   {
40599     try {
40600       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40601     } catch (std::out_of_range& e) {
40602       {
40603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40604       };
40605     } catch (std::exception& e) {
40606       {
40607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40608       };
40609     } catch (...) {
40610       {
40611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40612       };
40613     }
40614   }
40615   jresult = (void *)result;
40616   return jresult;
40617 }
40618
40619
40620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40621   void * jresult ;
40622   std::string *arg1 = 0 ;
40623   bool arg2 ;
40624   Dali::ResourceImage result;
40625
40626   if (!jarg1) {
40627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40628     return 0;
40629   }
40630   std::string arg1_str(jarg1);
40631   arg1 = &arg1_str;
40632   arg2 = jarg2 ? true : false;
40633   {
40634     try {
40635       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40643       };
40644     } catch (...) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40647       };
40648     }
40649   }
40650   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40651
40652   //argout typemap for const std::string&
40653
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40659   void * jresult ;
40660   std::string *arg1 = 0 ;
40661   Dali::ResourceImage result;
40662
40663   if (!jarg1) {
40664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40665     return 0;
40666   }
40667   std::string arg1_str(jarg1);
40668   arg1 = &arg1_str;
40669   {
40670     try {
40671       result = Dali::ResourceImage::New((std::string const &)*arg1);
40672     } catch (std::out_of_range& e) {
40673       {
40674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (std::exception& e) {
40677       {
40678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40679       };
40680     } catch (...) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40683       };
40684     }
40685   }
40686   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40687
40688   //argout typemap for const std::string&
40689
40690   return jresult;
40691 }
40692
40693
40694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40695   void * jresult ;
40696   std::string *arg1 = 0 ;
40697   Dali::ImageDimensions arg2 ;
40698   Dali::FittingMode::Type arg3 ;
40699   Dali::SamplingMode::Type arg4 ;
40700   bool arg5 ;
40701   Dali::ImageDimensions *argp2 ;
40702   Dali::ResourceImage result;
40703
40704   if (!jarg1) {
40705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40706     return 0;
40707   }
40708   std::string arg1_str(jarg1);
40709   arg1 = &arg1_str;
40710   argp2 = (Dali::ImageDimensions *)jarg2;
40711   if (!argp2) {
40712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40713     return 0;
40714   }
40715   arg2 = *argp2;
40716   arg3 = (Dali::FittingMode::Type)jarg3;
40717   arg4 = (Dali::SamplingMode::Type)jarg4;
40718   arg5 = jarg5 ? true : false;
40719   {
40720     try {
40721       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40722     } catch (std::out_of_range& e) {
40723       {
40724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40725       };
40726     } catch (std::exception& e) {
40727       {
40728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40729       };
40730     } catch (...) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40733       };
40734     }
40735   }
40736   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40737
40738   //argout typemap for const std::string&
40739
40740   return jresult;
40741 }
40742
40743
40744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40745   void * jresult ;
40746   std::string *arg1 = 0 ;
40747   Dali::ImageDimensions arg2 ;
40748   Dali::FittingMode::Type arg3 ;
40749   Dali::SamplingMode::Type arg4 ;
40750   Dali::ImageDimensions *argp2 ;
40751   Dali::ResourceImage result;
40752
40753   if (!jarg1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40755     return 0;
40756   }
40757   std::string arg1_str(jarg1);
40758   arg1 = &arg1_str;
40759   argp2 = (Dali::ImageDimensions *)jarg2;
40760   if (!argp2) {
40761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40762     return 0;
40763   }
40764   arg2 = *argp2;
40765   arg3 = (Dali::FittingMode::Type)jarg3;
40766   arg4 = (Dali::SamplingMode::Type)jarg4;
40767   {
40768     try {
40769       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40770     } catch (std::out_of_range& e) {
40771       {
40772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40773       };
40774     } catch (std::exception& e) {
40775       {
40776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40781       };
40782     }
40783   }
40784   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40785
40786   //argout typemap for const std::string&
40787
40788   return jresult;
40789 }
40790
40791
40792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40793   void * jresult ;
40794   std::string *arg1 = 0 ;
40795   Dali::ImageDimensions arg2 ;
40796   Dali::FittingMode::Type arg3 ;
40797   Dali::ImageDimensions *argp2 ;
40798   Dali::ResourceImage result;
40799
40800   if (!jarg1) {
40801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40802     return 0;
40803   }
40804   std::string arg1_str(jarg1);
40805   arg1 = &arg1_str;
40806   argp2 = (Dali::ImageDimensions *)jarg2;
40807   if (!argp2) {
40808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40809     return 0;
40810   }
40811   arg2 = *argp2;
40812   arg3 = (Dali::FittingMode::Type)jarg3;
40813   {
40814     try {
40815       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40816     } catch (std::out_of_range& e) {
40817       {
40818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40819       };
40820     } catch (std::exception& e) {
40821       {
40822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40823       };
40824     } catch (...) {
40825       {
40826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40827       };
40828     }
40829   }
40830   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40831
40832   //argout typemap for const std::string&
40833
40834   return jresult;
40835 }
40836
40837
40838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40839   void * jresult ;
40840   std::string *arg1 = 0 ;
40841   Dali::ImageDimensions arg2 ;
40842   Dali::ImageDimensions *argp2 ;
40843   Dali::ResourceImage result;
40844
40845   if (!jarg1) {
40846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40847     return 0;
40848   }
40849   std::string arg1_str(jarg1);
40850   arg1 = &arg1_str;
40851   argp2 = (Dali::ImageDimensions *)jarg2;
40852   if (!argp2) {
40853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40854     return 0;
40855   }
40856   arg2 = *argp2;
40857   {
40858     try {
40859       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40860     } catch (std::out_of_range& e) {
40861       {
40862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40863       };
40864     } catch (std::exception& e) {
40865       {
40866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40867       };
40868     } catch (...) {
40869       {
40870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40871       };
40872     }
40873   }
40874   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40875
40876   //argout typemap for const std::string&
40877
40878   return jresult;
40879 }
40880
40881
40882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40883   void * jresult ;
40884   Dali::BaseHandle arg1 ;
40885   Dali::BaseHandle *argp1 ;
40886   Dali::ResourceImage result;
40887
40888   argp1 = (Dali::BaseHandle *)jarg1;
40889   if (!argp1) {
40890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40891     return 0;
40892   }
40893   arg1 = *argp1;
40894   {
40895     try {
40896       result = Dali::ResourceImage::DownCast(arg1);
40897     } catch (std::out_of_range& e) {
40898       {
40899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40900       };
40901     } catch (std::exception& e) {
40902       {
40903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40904       };
40905     } catch (...) {
40906       {
40907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40908       };
40909     }
40910   }
40911   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40917   int jresult ;
40918   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40919   Dali::LoadingState result;
40920
40921   arg1 = (Dali::ResourceImage *)jarg1;
40922   {
40923     try {
40924       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40925     } catch (std::out_of_range& e) {
40926       {
40927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40928       };
40929     } catch (std::exception& e) {
40930       {
40931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40936       };
40937     }
40938   }
40939   jresult = (int)result;
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40945   char * jresult ;
40946   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40947   std::string result;
40948
40949   arg1 = (Dali::ResourceImage *)jarg1;
40950   {
40951     try {
40952       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40953     } catch (std::out_of_range& e) {
40954       {
40955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40956       };
40957     } catch (std::exception& e) {
40958       {
40959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40960       };
40961     } catch (...) {
40962       {
40963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40964       };
40965     }
40966   }
40967   jresult = SWIG_csharp_string_callback((&result)->c_str());
40968   return jresult;
40969 }
40970
40971
40972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40973   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40974
40975   arg1 = (Dali::ResourceImage *)jarg1;
40976   {
40977     try {
40978       (arg1)->Reload();
40979     } catch (std::out_of_range& e) {
40980       {
40981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40982       };
40983     } catch (std::exception& e) {
40984       {
40985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40986       };
40987     } catch (...) {
40988       {
40989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40990       };
40991     }
40992   }
40993 }
40994
40995
40996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40997   void * jresult ;
40998   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40999   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
41000
41001   arg1 = (Dali::ResourceImage *)jarg1;
41002   {
41003     try {
41004       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41005     } catch (std::out_of_range& e) {
41006       {
41007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41008       };
41009     } catch (std::exception& e) {
41010       {
41011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41012       };
41013     } catch (...) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41016       };
41017     }
41018   }
41019   jresult = (void *)result;
41020   return jresult;
41021 }
41022
41023
41024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41025   void * jresult ;
41026   Dali::FrameBufferImage *result = 0 ;
41027
41028   {
41029     try {
41030       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41031     } catch (std::out_of_range& e) {
41032       {
41033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (std::exception& e) {
41036       {
41037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045   jresult = (void *)result;
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41051   void * jresult ;
41052   unsigned int arg1 ;
41053   unsigned int arg2 ;
41054   Dali::Pixel::Format arg3 ;
41055   Dali::RenderBuffer::Format arg4 ;
41056   Dali::FrameBufferImage result;
41057
41058   arg1 = (unsigned int)jarg1;
41059   arg2 = (unsigned int)jarg2;
41060   arg3 = (Dali::Pixel::Format)jarg3;
41061   arg4 = (Dali::RenderBuffer::Format)jarg4;
41062   {
41063     try {
41064       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41065     } catch (std::out_of_range& e) {
41066       {
41067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41068       };
41069     } catch (std::exception& e) {
41070       {
41071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41072       };
41073     } catch (...) {
41074       {
41075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41076       };
41077     }
41078   }
41079   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41080   return jresult;
41081 }
41082
41083
41084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41085   void * jresult ;
41086   unsigned int arg1 ;
41087   unsigned int arg2 ;
41088   Dali::Pixel::Format arg3 ;
41089   Dali::FrameBufferImage result;
41090
41091   arg1 = (unsigned int)jarg1;
41092   arg2 = (unsigned int)jarg2;
41093   arg3 = (Dali::Pixel::Format)jarg3;
41094   {
41095     try {
41096       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41097     } catch (std::out_of_range& e) {
41098       {
41099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41100       };
41101     } catch (std::exception& e) {
41102       {
41103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41108       };
41109     }
41110   }
41111   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41112   return jresult;
41113 }
41114
41115
41116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41117   void * jresult ;
41118   unsigned int arg1 ;
41119   unsigned int arg2 ;
41120   Dali::FrameBufferImage result;
41121
41122   arg1 = (unsigned int)jarg1;
41123   arg2 = (unsigned int)jarg2;
41124   {
41125     try {
41126       result = Dali::FrameBufferImage::New(arg1,arg2);
41127     } catch (std::out_of_range& e) {
41128       {
41129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41130       };
41131     } catch (std::exception& e) {
41132       {
41133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41134       };
41135     } catch (...) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41138       };
41139     }
41140   }
41141   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41142   return jresult;
41143 }
41144
41145
41146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41147   void * jresult ;
41148   unsigned int arg1 ;
41149   Dali::FrameBufferImage result;
41150
41151   arg1 = (unsigned int)jarg1;
41152   {
41153     try {
41154       result = Dali::FrameBufferImage::New(arg1);
41155     } catch (std::out_of_range& e) {
41156       {
41157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41158       };
41159     } catch (std::exception& e) {
41160       {
41161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (...) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41166       };
41167     }
41168   }
41169   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41170   return jresult;
41171 }
41172
41173
41174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41175   void * jresult ;
41176   Dali::FrameBufferImage result;
41177
41178   {
41179     try {
41180       result = Dali::FrameBufferImage::New();
41181     } catch (std::out_of_range& e) {
41182       {
41183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41184       };
41185     } catch (std::exception& e) {
41186       {
41187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41188       };
41189     } catch (...) {
41190       {
41191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41192       };
41193     }
41194   }
41195   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41196   return jresult;
41197 }
41198
41199
41200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41201   void * jresult ;
41202   Dali::NativeImageInterface *arg1 = 0 ;
41203   Dali::FrameBufferImage result;
41204
41205   arg1 = (Dali::NativeImageInterface *)jarg1;
41206   if (!arg1) {
41207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41208     return 0;
41209   }
41210   {
41211     try {
41212       result = Dali::FrameBufferImage::New(*arg1);
41213     } catch (std::out_of_range& e) {
41214       {
41215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41216       };
41217     } catch (std::exception& e) {
41218       {
41219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41220       };
41221     } catch (...) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41224       };
41225     }
41226   }
41227   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41228   return jresult;
41229 }
41230
41231
41232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41233   void * jresult ;
41234   Dali::BaseHandle arg1 ;
41235   Dali::BaseHandle *argp1 ;
41236   Dali::FrameBufferImage result;
41237
41238   argp1 = (Dali::BaseHandle *)jarg1;
41239   if (!argp1) {
41240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41241     return 0;
41242   }
41243   arg1 = *argp1;
41244   {
41245     try {
41246       result = Dali::FrameBufferImage::DownCast(arg1);
41247     } catch (std::out_of_range& e) {
41248       {
41249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41250       };
41251     } catch (std::exception& e) {
41252       {
41253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41254       };
41255     } catch (...) {
41256       {
41257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41258       };
41259     }
41260   }
41261   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41262   return jresult;
41263 }
41264
41265
41266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41267   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41268
41269   arg1 = (Dali::FrameBufferImage *)jarg1;
41270   {
41271     try {
41272       delete arg1;
41273     } catch (std::out_of_range& e) {
41274       {
41275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41276       };
41277     } catch (std::exception& e) {
41278       {
41279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41280       };
41281     } catch (...) {
41282       {
41283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41284       };
41285     }
41286   }
41287 }
41288
41289
41290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41291   void * jresult ;
41292   Dali::FrameBufferImage *arg1 = 0 ;
41293   Dali::FrameBufferImage *result = 0 ;
41294
41295   arg1 = (Dali::FrameBufferImage *)jarg1;
41296   if (!arg1) {
41297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41298     return 0;
41299   }
41300   {
41301     try {
41302       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41303     } catch (std::out_of_range& e) {
41304       {
41305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (std::exception& e) {
41308       {
41309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41310       };
41311     } catch (...) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41314       };
41315     }
41316   }
41317   jresult = (void *)result;
41318   return jresult;
41319 }
41320
41321
41322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41323   void * jresult ;
41324   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41325   Dali::FrameBufferImage *arg2 = 0 ;
41326   Dali::FrameBufferImage *result = 0 ;
41327
41328   arg1 = (Dali::FrameBufferImage *)jarg1;
41329   arg2 = (Dali::FrameBufferImage *)jarg2;
41330   if (!arg2) {
41331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41332     return 0;
41333   }
41334   {
41335     try {
41336       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (...) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41348       };
41349     }
41350   }
41351   jresult = (void *)result;
41352   return jresult;
41353 }
41354
41355
41356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41357   void * jresult ;
41358   Dali::NinePatchImage *result = 0 ;
41359
41360   {
41361     try {
41362       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41363     } catch (std::out_of_range& e) {
41364       {
41365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41366       };
41367     } catch (std::exception& e) {
41368       {
41369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41370       };
41371     } catch (...) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41374       };
41375     }
41376   }
41377   jresult = (void *)result;
41378   return jresult;
41379 }
41380
41381
41382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41383   void * jresult ;
41384   std::string *arg1 = 0 ;
41385   Dali::NinePatchImage result;
41386
41387   if (!jarg1) {
41388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41389     return 0;
41390   }
41391   std::string arg1_str(jarg1);
41392   arg1 = &arg1_str;
41393   {
41394     try {
41395       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41396     } catch (std::out_of_range& e) {
41397       {
41398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41399       };
41400     } catch (std::exception& e) {
41401       {
41402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41403       };
41404     } catch (...) {
41405       {
41406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41407       };
41408     }
41409   }
41410   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41411
41412   //argout typemap for const std::string&
41413
41414   return jresult;
41415 }
41416
41417
41418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41419   void * jresult ;
41420   Dali::BaseHandle arg1 ;
41421   Dali::BaseHandle *argp1 ;
41422   Dali::NinePatchImage result;
41423
41424   argp1 = (Dali::BaseHandle *)jarg1;
41425   if (!argp1) {
41426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41427     return 0;
41428   }
41429   arg1 = *argp1;
41430   {
41431     try {
41432       result = Dali::NinePatchImage::DownCast(arg1);
41433     } catch (std::out_of_range& e) {
41434       {
41435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (std::exception& e) {
41438       {
41439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41453   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41454
41455   arg1 = (Dali::NinePatchImage *)jarg1;
41456   {
41457     try {
41458       delete arg1;
41459     } catch (std::out_of_range& e) {
41460       {
41461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41462       };
41463     } catch (std::exception& e) {
41464       {
41465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41466       };
41467     } catch (...) {
41468       {
41469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41470       };
41471     }
41472   }
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41477   void * jresult ;
41478   Dali::NinePatchImage *arg1 = 0 ;
41479   Dali::NinePatchImage *result = 0 ;
41480
41481   arg1 = (Dali::NinePatchImage *)jarg1;
41482   if (!arg1) {
41483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41484     return 0;
41485   }
41486   {
41487     try {
41488       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41489     } catch (std::out_of_range& e) {
41490       {
41491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41492       };
41493     } catch (std::exception& e) {
41494       {
41495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41496       };
41497     } catch (...) {
41498       {
41499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41500       };
41501     }
41502   }
41503   jresult = (void *)result;
41504   return jresult;
41505 }
41506
41507
41508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41509   void * jresult ;
41510   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41511   Dali::NinePatchImage *arg2 = 0 ;
41512   Dali::NinePatchImage *result = 0 ;
41513
41514   arg1 = (Dali::NinePatchImage *)jarg1;
41515   arg2 = (Dali::NinePatchImage *)jarg2;
41516   if (!arg2) {
41517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41518     return 0;
41519   }
41520   {
41521     try {
41522       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41523     } catch (std::out_of_range& e) {
41524       {
41525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41526       };
41527     } catch (std::exception& e) {
41528       {
41529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41530       };
41531     } catch (...) {
41532       {
41533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41534       };
41535     }
41536   }
41537   jresult = (void *)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41543   void * jresult ;
41544   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41545   Dali::Vector4 result;
41546
41547   arg1 = (Dali::NinePatchImage *)jarg1;
41548   {
41549     try {
41550       result = (arg1)->GetStretchBorders();
41551     } catch (std::out_of_range& e) {
41552       {
41553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41554       };
41555     } catch (std::exception& e) {
41556       {
41557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41562       };
41563     }
41564   }
41565   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41566   return jresult;
41567 }
41568
41569
41570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41571   void * jresult ;
41572   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41573   Dali::NinePatchImage::StretchRanges *result = 0 ;
41574
41575   arg1 = (Dali::NinePatchImage *)jarg1;
41576   {
41577     try {
41578       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41579     } catch (std::out_of_range& e) {
41580       {
41581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (std::exception& e) {
41584       {
41585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41586       };
41587     } catch (...) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41590       };
41591     }
41592   }
41593   jresult = (void *)result;
41594   return jresult;
41595 }
41596
41597
41598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41599   void * jresult ;
41600   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41601   Dali::NinePatchImage::StretchRanges *result = 0 ;
41602
41603   arg1 = (Dali::NinePatchImage *)jarg1;
41604   {
41605     try {
41606       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41607     } catch (std::out_of_range& e) {
41608       {
41609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41610       };
41611     } catch (std::exception& e) {
41612       {
41613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41614       };
41615     } catch (...) {
41616       {
41617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41618       };
41619     }
41620   }
41621   jresult = (void *)result;
41622   return jresult;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41627   void * jresult ;
41628   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41629   Dali::Rect< int > result;
41630
41631   arg1 = (Dali::NinePatchImage *)jarg1;
41632   {
41633     try {
41634       result = (arg1)->GetChildRectangle();
41635     } catch (std::out_of_range& e) {
41636       {
41637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (std::exception& e) {
41640       {
41641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41642       };
41643     } catch (...) {
41644       {
41645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41646       };
41647     }
41648   }
41649   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41650   return jresult;
41651 }
41652
41653
41654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41655   void * jresult ;
41656   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41657   Dali::BufferImage result;
41658
41659   arg1 = (Dali::NinePatchImage *)jarg1;
41660   {
41661     try {
41662       result = (arg1)->CreateCroppedBufferImage();
41663     } catch (std::out_of_range& e) {
41664       {
41665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41666       };
41667     } catch (std::exception& e) {
41668       {
41669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41670       };
41671     } catch (...) {
41672       {
41673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41674       };
41675     }
41676   }
41677   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41683   unsigned int jresult ;
41684   std::string *arg1 = 0 ;
41685   bool result;
41686
41687   if (!jarg1) {
41688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41689     return 0;
41690   }
41691   std::string arg1_str(jarg1);
41692   arg1 = &arg1_str;
41693   {
41694     try {
41695       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41696     } catch (std::out_of_range& e) {
41697       {
41698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41699       };
41700     } catch (std::exception& e) {
41701       {
41702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41703       };
41704     } catch (...) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41707       };
41708     }
41709   }
41710   jresult = result;
41711
41712   //argout typemap for const std::string&
41713
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41719   int jresult ;
41720   int result;
41721
41722   result = (int)Dali::CameraActor::Property::TYPE;
41723   jresult = (int)result;
41724   return jresult;
41725 }
41726
41727
41728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41729   int jresult ;
41730   int result;
41731
41732   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41733   jresult = (int)result;
41734   return jresult;
41735 }
41736
41737
41738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41739   int jresult ;
41740   int result;
41741
41742   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41743   jresult = (int)result;
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41749   int jresult ;
41750   int result;
41751
41752   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41753   jresult = (int)result;
41754   return jresult;
41755 }
41756
41757
41758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41759   int jresult ;
41760   int result;
41761
41762   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41763   jresult = (int)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41769   int jresult ;
41770   int result;
41771
41772   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41773   jresult = (int)result;
41774   return jresult;
41775 }
41776
41777
41778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41779   int jresult ;
41780   int result;
41781
41782   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41783   jresult = (int)result;
41784   return jresult;
41785 }
41786
41787
41788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41789   int jresult ;
41790   int result;
41791
41792   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41793   jresult = (int)result;
41794   return jresult;
41795 }
41796
41797
41798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41799   int jresult ;
41800   int result;
41801
41802   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41803   jresult = (int)result;
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41809   int jresult ;
41810   int result;
41811
41812   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41813   jresult = (int)result;
41814   return jresult;
41815 }
41816
41817
41818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41819   int jresult ;
41820   int result;
41821
41822   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41823   jresult = (int)result;
41824   return jresult;
41825 }
41826
41827
41828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41829   int jresult ;
41830   int result;
41831
41832   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41833   jresult = (int)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41839   int jresult ;
41840   int result;
41841
41842   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41843   jresult = (int)result;
41844   return jresult;
41845 }
41846
41847
41848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41849   int jresult ;
41850   int result;
41851
41852   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41853   jresult = (int)result;
41854   return jresult;
41855 }
41856
41857
41858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41859   void * jresult ;
41860   Dali::CameraActor::Property *result = 0 ;
41861
41862   {
41863     try {
41864       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41865     } catch (std::out_of_range& e) {
41866       {
41867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (std::exception& e) {
41870       {
41871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879   jresult = (void *)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41885   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41886
41887   arg1 = (Dali::CameraActor::Property *)jarg1;
41888   {
41889     try {
41890       delete arg1;
41891     } catch (std::out_of_range& e) {
41892       {
41893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41894       };
41895     } catch (std::exception& e) {
41896       {
41897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41898       };
41899     } catch (...) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41902       };
41903     }
41904   }
41905 }
41906
41907
41908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41909   void * jresult ;
41910   Dali::CameraActor *result = 0 ;
41911
41912   {
41913     try {
41914       result = (Dali::CameraActor *)new Dali::CameraActor();
41915     } catch (std::out_of_range& e) {
41916       {
41917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41918       };
41919     } catch (std::exception& e) {
41920       {
41921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41922       };
41923     } catch (...) {
41924       {
41925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41926       };
41927     }
41928   }
41929   jresult = (void *)result;
41930   return jresult;
41931 }
41932
41933
41934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41935   void * jresult ;
41936   Dali::CameraActor result;
41937
41938   {
41939     try {
41940       result = Dali::CameraActor::New();
41941     } catch (std::out_of_range& e) {
41942       {
41943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (std::exception& e) {
41946       {
41947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41948       };
41949     } catch (...) {
41950       {
41951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41952       };
41953     }
41954   }
41955   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41956   return jresult;
41957 }
41958
41959
41960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41961   void * jresult ;
41962   Dali::Size *arg1 = 0 ;
41963   Dali::CameraActor result;
41964
41965   arg1 = (Dali::Size *)jarg1;
41966   if (!arg1) {
41967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41968     return 0;
41969   }
41970   {
41971     try {
41972       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41973     } catch (std::out_of_range& e) {
41974       {
41975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41976       };
41977     } catch (std::exception& e) {
41978       {
41979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41980       };
41981     } catch (...) {
41982       {
41983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41984       };
41985     }
41986   }
41987   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41988   return jresult;
41989 }
41990
41991
41992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41993   void * jresult ;
41994   Dali::BaseHandle arg1 ;
41995   Dali::BaseHandle *argp1 ;
41996   Dali::CameraActor result;
41997
41998   argp1 = (Dali::BaseHandle *)jarg1;
41999   if (!argp1) {
42000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42001     return 0;
42002   }
42003   arg1 = *argp1;
42004   {
42005     try {
42006       result = Dali::CameraActor::DownCast(arg1);
42007     } catch (std::out_of_range& e) {
42008       {
42009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (std::exception& e) {
42012       {
42013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42014       };
42015     } catch (...) {
42016       {
42017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42018       };
42019     }
42020   }
42021   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42022   return jresult;
42023 }
42024
42025
42026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42027   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42028
42029   arg1 = (Dali::CameraActor *)jarg1;
42030   {
42031     try {
42032       delete arg1;
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42040       };
42041     } catch (...) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42044       };
42045     }
42046   }
42047 }
42048
42049
42050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42051   void * jresult ;
42052   Dali::CameraActor *arg1 = 0 ;
42053   Dali::CameraActor *result = 0 ;
42054
42055   arg1 = (Dali::CameraActor *)jarg1;
42056   if (!arg1) {
42057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42058     return 0;
42059   }
42060   {
42061     try {
42062       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42063     } catch (std::out_of_range& e) {
42064       {
42065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42066       };
42067     } catch (std::exception& e) {
42068       {
42069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42070       };
42071     } catch (...) {
42072       {
42073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42074       };
42075     }
42076   }
42077   jresult = (void *)result;
42078   return jresult;
42079 }
42080
42081
42082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42083   void * jresult ;
42084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42085   Dali::CameraActor *arg2 = 0 ;
42086   Dali::CameraActor *result = 0 ;
42087
42088   arg1 = (Dali::CameraActor *)jarg1;
42089   arg2 = (Dali::CameraActor *)jarg2;
42090   if (!arg2) {
42091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42092     return 0;
42093   }
42094   {
42095     try {
42096       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42097     } catch (std::out_of_range& e) {
42098       {
42099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42100       };
42101     } catch (std::exception& e) {
42102       {
42103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42104       };
42105     } catch (...) {
42106       {
42107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42108       };
42109     }
42110   }
42111   jresult = (void *)result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42118   Dali::Camera::Type arg2 ;
42119
42120   arg1 = (Dali::CameraActor *)jarg1;
42121   arg2 = (Dali::Camera::Type)jarg2;
42122   {
42123     try {
42124       (arg1)->SetType(arg2);
42125     } catch (std::out_of_range& e) {
42126       {
42127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42128       };
42129     } catch (std::exception& e) {
42130       {
42131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42132       };
42133     } catch (...) {
42134       {
42135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42136       };
42137     }
42138   }
42139 }
42140
42141
42142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42143   int jresult ;
42144   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42145   Dali::Camera::Type result;
42146
42147   arg1 = (Dali::CameraActor *)jarg1;
42148   {
42149     try {
42150       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42151     } catch (std::out_of_range& e) {
42152       {
42153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42154       };
42155     } catch (std::exception& e) {
42156       {
42157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42158       };
42159     } catch (...) {
42160       {
42161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42162       };
42163     }
42164   }
42165   jresult = (int)result;
42166   return jresult;
42167 }
42168
42169
42170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42171   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42172   Dali::Camera::ProjectionMode arg2 ;
42173
42174   arg1 = (Dali::CameraActor *)jarg1;
42175   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42176   {
42177     try {
42178       (arg1)->SetProjectionMode(arg2);
42179     } catch (std::out_of_range& e) {
42180       {
42181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42182       };
42183     } catch (std::exception& e) {
42184       {
42185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42186       };
42187     } catch (...) {
42188       {
42189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42190       };
42191     }
42192   }
42193 }
42194
42195
42196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42197   int jresult ;
42198   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42199   Dali::Camera::ProjectionMode result;
42200
42201   arg1 = (Dali::CameraActor *)jarg1;
42202   {
42203     try {
42204       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42205     } catch (std::out_of_range& e) {
42206       {
42207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42208       };
42209     } catch (std::exception& e) {
42210       {
42211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (...) {
42214       {
42215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42216       };
42217     }
42218   }
42219   jresult = (int)result;
42220   return jresult;
42221 }
42222
42223
42224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42225   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42226   float arg2 ;
42227
42228   arg1 = (Dali::CameraActor *)jarg1;
42229   arg2 = (float)jarg2;
42230   {
42231     try {
42232       (arg1)->SetFieldOfView(arg2);
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42244       };
42245     }
42246   }
42247 }
42248
42249
42250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42251   float jresult ;
42252   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42253   float result;
42254
42255   arg1 = (Dali::CameraActor *)jarg1;
42256   {
42257     try {
42258       result = (float)(arg1)->GetFieldOfView();
42259     } catch (std::out_of_range& e) {
42260       {
42261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42262       };
42263     } catch (std::exception& e) {
42264       {
42265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42266       };
42267     } catch (...) {
42268       {
42269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42270       };
42271     }
42272   }
42273   jresult = result;
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42279   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42280   float arg2 ;
42281
42282   arg1 = (Dali::CameraActor *)jarg1;
42283   arg2 = (float)jarg2;
42284   {
42285     try {
42286       (arg1)->SetAspectRatio(arg2);
42287     } catch (std::out_of_range& e) {
42288       {
42289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42290       };
42291     } catch (std::exception& e) {
42292       {
42293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42294       };
42295     } catch (...) {
42296       {
42297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42298       };
42299     }
42300   }
42301 }
42302
42303
42304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42305   float jresult ;
42306   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42307   float result;
42308
42309   arg1 = (Dali::CameraActor *)jarg1;
42310   {
42311     try {
42312       result = (float)(arg1)->GetAspectRatio();
42313     } catch (std::out_of_range& e) {
42314       {
42315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (std::exception& e) {
42318       {
42319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42320       };
42321     } catch (...) {
42322       {
42323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42324       };
42325     }
42326   }
42327   jresult = result;
42328   return jresult;
42329 }
42330
42331
42332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42333   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42334   float arg2 ;
42335
42336   arg1 = (Dali::CameraActor *)jarg1;
42337   arg2 = (float)jarg2;
42338   {
42339     try {
42340       (arg1)->SetNearClippingPlane(arg2);
42341     } catch (std::out_of_range& e) {
42342       {
42343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42344       };
42345     } catch (std::exception& e) {
42346       {
42347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42352       };
42353     }
42354   }
42355 }
42356
42357
42358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42359   float jresult ;
42360   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42361   float result;
42362
42363   arg1 = (Dali::CameraActor *)jarg1;
42364   {
42365     try {
42366       result = (float)(arg1)->GetNearClippingPlane();
42367     } catch (std::out_of_range& e) {
42368       {
42369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42370       };
42371     } catch (std::exception& e) {
42372       {
42373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42374       };
42375     } catch (...) {
42376       {
42377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42378       };
42379     }
42380   }
42381   jresult = result;
42382   return jresult;
42383 }
42384
42385
42386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42387   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42388   float arg2 ;
42389
42390   arg1 = (Dali::CameraActor *)jarg1;
42391   arg2 = (float)jarg2;
42392   {
42393     try {
42394       (arg1)->SetFarClippingPlane(arg2);
42395     } catch (std::out_of_range& e) {
42396       {
42397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42398       };
42399     } catch (std::exception& e) {
42400       {
42401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42402       };
42403     } catch (...) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42406       };
42407     }
42408   }
42409 }
42410
42411
42412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42413   float jresult ;
42414   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42415   float result;
42416
42417   arg1 = (Dali::CameraActor *)jarg1;
42418   {
42419     try {
42420       result = (float)(arg1)->GetFarClippingPlane();
42421     } catch (std::out_of_range& e) {
42422       {
42423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42424       };
42425     } catch (std::exception& e) {
42426       {
42427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42428       };
42429     } catch (...) {
42430       {
42431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42432       };
42433     }
42434   }
42435   jresult = result;
42436   return jresult;
42437 }
42438
42439
42440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42441   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42442   Dali::Vector3 *arg2 = 0 ;
42443
42444   arg1 = (Dali::CameraActor *)jarg1;
42445   arg2 = (Dali::Vector3 *)jarg2;
42446   if (!arg2) {
42447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42448     return ;
42449   }
42450   {
42451     try {
42452       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42453     } catch (std::out_of_range& e) {
42454       {
42455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42456       };
42457     } catch (std::exception& e) {
42458       {
42459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42460       };
42461     } catch (...) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42464       };
42465     }
42466   }
42467 }
42468
42469
42470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42471   void * jresult ;
42472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42473   Dali::Vector3 result;
42474
42475   arg1 = (Dali::CameraActor *)jarg1;
42476   {
42477     try {
42478       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42479     } catch (std::out_of_range& e) {
42480       {
42481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42482       };
42483     } catch (std::exception& e) {
42484       {
42485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (...) {
42488       {
42489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42490       };
42491     }
42492   }
42493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42494   return jresult;
42495 }
42496
42497
42498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42499   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42500   bool arg2 ;
42501
42502   arg1 = (Dali::CameraActor *)jarg1;
42503   arg2 = jarg2 ? true : false;
42504   {
42505     try {
42506       (arg1)->SetInvertYAxis(arg2);
42507     } catch (std::out_of_range& e) {
42508       {
42509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42510       };
42511     } catch (std::exception& e) {
42512       {
42513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42514       };
42515     } catch (...) {
42516       {
42517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42518       };
42519     }
42520   }
42521 }
42522
42523
42524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42525   unsigned int jresult ;
42526   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42527   bool result;
42528
42529   arg1 = (Dali::CameraActor *)jarg1;
42530   {
42531     try {
42532       result = (bool)(arg1)->GetInvertYAxis();
42533     } catch (std::out_of_range& e) {
42534       {
42535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42536       };
42537     } catch (std::exception& e) {
42538       {
42539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42540       };
42541     } catch (...) {
42542       {
42543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42544       };
42545     }
42546   }
42547   jresult = result;
42548   return jresult;
42549 }
42550
42551
42552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42553   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42554   Dali::Size *arg2 = 0 ;
42555
42556   arg1 = (Dali::CameraActor *)jarg1;
42557   arg2 = (Dali::Size *)jarg2;
42558   if (!arg2) {
42559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42560     return ;
42561   }
42562   {
42563     try {
42564       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42565     } catch (std::out_of_range& e) {
42566       {
42567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42568       };
42569     } catch (std::exception& e) {
42570       {
42571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42572       };
42573     } catch (...) {
42574       {
42575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42576       };
42577     }
42578   }
42579 }
42580
42581
42582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42583   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42584   Dali::Size *arg2 = 0 ;
42585
42586   arg1 = (Dali::CameraActor *)jarg1;
42587   arg2 = (Dali::Size *)jarg2;
42588   if (!arg2) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42590     return ;
42591   }
42592   {
42593     try {
42594       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42595     } catch (std::out_of_range& e) {
42596       {
42597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42598       };
42599     } catch (std::exception& e) {
42600       {
42601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42602       };
42603     } catch (...) {
42604       {
42605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42606       };
42607     }
42608   }
42609 }
42610
42611
42612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42613   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42614   float arg2 ;
42615   float arg3 ;
42616   float arg4 ;
42617   float arg5 ;
42618   float arg6 ;
42619   float arg7 ;
42620
42621   arg1 = (Dali::CameraActor *)jarg1;
42622   arg2 = (float)jarg2;
42623   arg3 = (float)jarg3;
42624   arg4 = (float)jarg4;
42625   arg5 = (float)jarg5;
42626   arg6 = (float)jarg6;
42627   arg7 = (float)jarg7;
42628   {
42629     try {
42630       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42631     } catch (std::out_of_range& e) {
42632       {
42633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42634       };
42635     } catch (std::exception& e) {
42636       {
42637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42638       };
42639     } catch (...) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42642       };
42643     }
42644   }
42645 }
42646
42647
42648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42649   void * jresult ;
42650   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42651
42652   {
42653     try {
42654       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42655     } catch (std::out_of_range& e) {
42656       {
42657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (std::exception& e) {
42660       {
42661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (...) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42666       };
42667     }
42668   }
42669   jresult = (void *)result;
42670   return jresult;
42671 }
42672
42673
42674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42675   void * jresult ;
42676   std::string arg1 ;
42677   Dali::Property::Value arg2 ;
42678   Dali::Property::Value *argp2 ;
42679   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42680
42681   if (!jarg1) {
42682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42683     return 0;
42684   }
42685   (&arg1)->assign(jarg1);
42686   argp2 = (Dali::Property::Value *)jarg2;
42687   if (!argp2) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42689     return 0;
42690   }
42691   arg2 = *argp2;
42692   {
42693     try {
42694       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42695     } catch (std::out_of_range& e) {
42696       {
42697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42698       };
42699     } catch (std::exception& e) {
42700       {
42701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42702       };
42703     } catch (...) {
42704       {
42705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42706       };
42707     }
42708   }
42709   jresult = (void *)result;
42710   return jresult;
42711 }
42712
42713
42714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42715   void * jresult ;
42716   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42717   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42718
42719   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42720   if (!arg1) {
42721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42722     return 0;
42723   }
42724   {
42725     try {
42726       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);
42727     } catch (std::out_of_range& e) {
42728       {
42729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42730       };
42731     } catch (std::exception& e) {
42732       {
42733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42734       };
42735     } catch (...) {
42736       {
42737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42738       };
42739     }
42740   }
42741   jresult = (void *)result;
42742   return jresult;
42743 }
42744
42745
42746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42747   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42748   std::string *arg2 = 0 ;
42749
42750   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42751   if (!jarg2) {
42752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42753     return ;
42754   }
42755   std::string arg2_str(jarg2);
42756   arg2 = &arg2_str;
42757   if (arg1) (arg1)->first = *arg2;
42758
42759   //argout typemap for const std::string&
42760
42761 }
42762
42763
42764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42765   char * jresult ;
42766   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42767   std::string *result = 0 ;
42768
42769   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42770   result = (std::string *) & ((arg1)->first);
42771   jresult = SWIG_csharp_string_callback(result->c_str());
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42777   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42778   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42779
42780   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42781   arg2 = (Dali::Property::Value *)jarg2;
42782   if (arg1) (arg1)->second = *arg2;
42783 }
42784
42785
42786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42787   void * jresult ;
42788   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42789   Dali::Property::Value *result = 0 ;
42790
42791   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42792   result = (Dali::Property::Value *)& ((arg1)->second);
42793   jresult = (void *)result;
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42799   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42800
42801   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42802   {
42803     try {
42804       delete arg1;
42805     } catch (std::out_of_range& e) {
42806       {
42807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42808       };
42809     } catch (std::exception& e) {
42810       {
42811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42812       };
42813     } catch (...) {
42814       {
42815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42816       };
42817     }
42818   }
42819 }
42820
42821
42822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42824
42825   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42826   {
42827     try {
42828       (arg1)->clear();
42829     } catch (std::out_of_range& e) {
42830       {
42831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42832       };
42833     } catch (std::exception& e) {
42834       {
42835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42836       };
42837     } catch (...) {
42838       {
42839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42840       };
42841     }
42842   }
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42847   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42848   Dali::TouchPoint *arg2 = 0 ;
42849
42850   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42851   arg2 = (Dali::TouchPoint *)jarg2;
42852   if (!arg2) {
42853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42854     return ;
42855   }
42856   {
42857     try {
42858       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42866       };
42867     } catch (...) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42870       };
42871     }
42872   }
42873 }
42874
42875
42876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42877   unsigned long jresult ;
42878   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42879   std::vector< Dali::TouchPoint >::size_type result;
42880
42881   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42882   {
42883     try {
42884       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42885     } catch (std::out_of_range& e) {
42886       {
42887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (std::exception& e) {
42890       {
42891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42892       };
42893     } catch (...) {
42894       {
42895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42896       };
42897     }
42898   }
42899   jresult = (unsigned long)result;
42900   return jresult;
42901 }
42902
42903
42904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42905   unsigned long jresult ;
42906   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42907   std::vector< Dali::TouchPoint >::size_type result;
42908
42909   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42910   {
42911     try {
42912       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42913     } catch (std::out_of_range& e) {
42914       {
42915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42916       };
42917     } catch (std::exception& e) {
42918       {
42919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42920       };
42921     } catch (...) {
42922       {
42923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42924       };
42925     }
42926   }
42927   jresult = (unsigned long)result;
42928   return jresult;
42929 }
42930
42931
42932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42933   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42934   std::vector< Dali::TouchPoint >::size_type arg2 ;
42935
42936   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42937   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42938   {
42939     try {
42940       (arg1)->reserve(arg2);
42941     } catch (std::out_of_range& e) {
42942       {
42943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42944       };
42945     } catch (std::exception& e) {
42946       {
42947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42948       };
42949     } catch (...) {
42950       {
42951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42952       };
42953     }
42954   }
42955 }
42956
42957
42958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42959   void * jresult ;
42960   std::vector< Dali::TouchPoint > *result = 0 ;
42961
42962   {
42963     try {
42964       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42965     } catch (std::out_of_range& e) {
42966       {
42967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42968       };
42969     } catch (std::exception& e) {
42970       {
42971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (...) {
42974       {
42975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42976       };
42977     }
42978   }
42979   jresult = (void *)result;
42980   return jresult;
42981 }
42982
42983
42984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42985   void * jresult ;
42986   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42987   std::vector< Dali::TouchPoint > *result = 0 ;
42988
42989   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42990   if (!arg1) {
42991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42992     return 0;
42993   }
42994   {
42995     try {
42996       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42997     } catch (std::out_of_range& e) {
42998       {
42999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43000       };
43001     } catch (std::exception& e) {
43002       {
43003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (...) {
43006       {
43007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43008       };
43009     }
43010   }
43011   jresult = (void *)result;
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43017   void * jresult ;
43018   int arg1 ;
43019   std::vector< Dali::TouchPoint > *result = 0 ;
43020
43021   arg1 = (int)jarg1;
43022   {
43023     try {
43024       try {
43025         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43026       }
43027       catch(std::out_of_range &_e) {
43028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43029         return 0;
43030       }
43031
43032     } catch (std::out_of_range& e) {
43033       {
43034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43035       };
43036     } catch (std::exception& e) {
43037       {
43038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43039       };
43040     } catch (...) {
43041       {
43042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43043       };
43044     }
43045   }
43046   jresult = (void *)result;
43047   return jresult;
43048 }
43049
43050
43051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43052   void * jresult ;
43053   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43054   int arg2 ;
43055   SwigValueWrapper< Dali::TouchPoint > result;
43056
43057   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43058   arg2 = (int)jarg2;
43059   {
43060     try {
43061       try {
43062         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43063       }
43064       catch(std::out_of_range &_e) {
43065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43066         return 0;
43067       }
43068
43069     } catch (std::out_of_range& e) {
43070       {
43071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43072       };
43073     } catch (std::exception& e) {
43074       {
43075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43076       };
43077     } catch (...) {
43078       {
43079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43080       };
43081     }
43082   }
43083   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43084   return jresult;
43085 }
43086
43087
43088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43089   void * jresult ;
43090   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43091   int arg2 ;
43092   Dali::TouchPoint *result = 0 ;
43093
43094   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43095   arg2 = (int)jarg2;
43096   {
43097     try {
43098       try {
43099         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43100       }
43101       catch(std::out_of_range &_e) {
43102         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43103         return 0;
43104       }
43105
43106     } catch (std::out_of_range& e) {
43107       {
43108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (std::exception& e) {
43111       {
43112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (...) {
43115       {
43116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43117       };
43118     }
43119   }
43120   jresult = (void *)result;
43121   return jresult;
43122 }
43123
43124
43125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43126   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43127   int arg2 ;
43128   Dali::TouchPoint *arg3 = 0 ;
43129
43130   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43131   arg2 = (int)jarg2;
43132   arg3 = (Dali::TouchPoint *)jarg3;
43133   if (!arg3) {
43134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43135     return ;
43136   }
43137   {
43138     try {
43139       try {
43140         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43141       }
43142       catch(std::out_of_range &_e) {
43143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43144         return ;
43145       }
43146
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43154       };
43155     } catch (...) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43158       };
43159     }
43160   }
43161 }
43162
43163
43164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43165   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43166   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43167
43168   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43169   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43170   if (!arg2) {
43171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43172     return ;
43173   }
43174   {
43175     try {
43176       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43177     } catch (std::out_of_range& e) {
43178       {
43179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43180       };
43181     } catch (std::exception& e) {
43182       {
43183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43184       };
43185     } catch (...) {
43186       {
43187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43188       };
43189     }
43190   }
43191 }
43192
43193
43194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43195   void * jresult ;
43196   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43197   int arg2 ;
43198   int arg3 ;
43199   std::vector< Dali::TouchPoint > *result = 0 ;
43200
43201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43202   arg2 = (int)jarg2;
43203   arg3 = (int)jarg3;
43204   {
43205     try {
43206       try {
43207         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43208       }
43209       catch(std::out_of_range &_e) {
43210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43211         return 0;
43212       }
43213       catch(std::invalid_argument &_e) {
43214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43215         return 0;
43216       }
43217
43218     } catch (std::out_of_range& e) {
43219       {
43220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43221       };
43222     } catch (std::exception& e) {
43223       {
43224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43225       };
43226     } catch (...) {
43227       {
43228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43229       };
43230     }
43231   }
43232   jresult = (void *)result;
43233   return jresult;
43234 }
43235
43236
43237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43238   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43239   int arg2 ;
43240   Dali::TouchPoint *arg3 = 0 ;
43241
43242   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43243   arg2 = (int)jarg2;
43244   arg3 = (Dali::TouchPoint *)jarg3;
43245   if (!arg3) {
43246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43247     return ;
43248   }
43249   {
43250     try {
43251       try {
43252         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43253       }
43254       catch(std::out_of_range &_e) {
43255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43256         return ;
43257       }
43258
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43266       };
43267     } catch (...) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43270       };
43271     }
43272   }
43273 }
43274
43275
43276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43277   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43278   int arg2 ;
43279   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43280
43281   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43282   arg2 = (int)jarg2;
43283   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43284   if (!arg3) {
43285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43286     return ;
43287   }
43288   {
43289     try {
43290       try {
43291         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43292       }
43293       catch(std::out_of_range &_e) {
43294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43295         return ;
43296       }
43297
43298     } catch (std::out_of_range& e) {
43299       {
43300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (std::exception& e) {
43303       {
43304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (...) {
43307       {
43308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43309       };
43310     }
43311   }
43312 }
43313
43314
43315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43316   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43317   int arg2 ;
43318
43319   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43320   arg2 = (int)jarg2;
43321   {
43322     try {
43323       try {
43324         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43325       }
43326       catch(std::out_of_range &_e) {
43327         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43328         return ;
43329       }
43330
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43338       };
43339     } catch (...) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43342       };
43343     }
43344   }
43345 }
43346
43347
43348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43349   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43350   int arg2 ;
43351   int arg3 ;
43352
43353   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43354   arg2 = (int)jarg2;
43355   arg3 = (int)jarg3;
43356   {
43357     try {
43358       try {
43359         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43360       }
43361       catch(std::out_of_range &_e) {
43362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43363         return ;
43364       }
43365       catch(std::invalid_argument &_e) {
43366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43367         return ;
43368       }
43369
43370     } catch (std::out_of_range& e) {
43371       {
43372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43373       };
43374     } catch (std::exception& e) {
43375       {
43376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43377       };
43378     } catch (...) {
43379       {
43380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43381       };
43382     }
43383   }
43384 }
43385
43386
43387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43388   void * jresult ;
43389   Dali::TouchPoint *arg1 = 0 ;
43390   int arg2 ;
43391   std::vector< Dali::TouchPoint > *result = 0 ;
43392
43393   arg1 = (Dali::TouchPoint *)jarg1;
43394   if (!arg1) {
43395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43396     return 0;
43397   }
43398   arg2 = (int)jarg2;
43399   {
43400     try {
43401       try {
43402         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43403       }
43404       catch(std::out_of_range &_e) {
43405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43406         return 0;
43407       }
43408
43409     } catch (std::out_of_range& e) {
43410       {
43411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (std::exception& e) {
43414       {
43415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (...) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43420       };
43421     }
43422   }
43423   jresult = (void *)result;
43424   return jresult;
43425 }
43426
43427
43428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43429   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43430
43431   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43432   {
43433     try {
43434       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43435     } catch (std::out_of_range& e) {
43436       {
43437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43438       };
43439     } catch (std::exception& e) {
43440       {
43441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43442       };
43443     } catch (...) {
43444       {
43445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43446       };
43447     }
43448   }
43449 }
43450
43451
43452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43454   int arg2 ;
43455   int arg3 ;
43456
43457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43458   arg2 = (int)jarg2;
43459   arg3 = (int)jarg3;
43460   {
43461     try {
43462       try {
43463         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43464       }
43465       catch(std::out_of_range &_e) {
43466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43467         return ;
43468       }
43469       catch(std::invalid_argument &_e) {
43470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43471         return ;
43472       }
43473
43474     } catch (std::out_of_range& e) {
43475       {
43476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43477       };
43478     } catch (std::exception& e) {
43479       {
43480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43481       };
43482     } catch (...) {
43483       {
43484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43485       };
43486     }
43487   }
43488 }
43489
43490
43491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43492   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43493   int arg2 ;
43494   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43495
43496   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43497   arg2 = (int)jarg2;
43498   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43499   if (!arg3) {
43500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43501     return ;
43502   }
43503   {
43504     try {
43505       try {
43506         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43507       }
43508       catch(std::out_of_range &_e) {
43509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43510         return ;
43511       }
43512
43513     } catch (std::out_of_range& e) {
43514       {
43515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43516       };
43517     } catch (std::exception& e) {
43518       {
43519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43520       };
43521     } catch (...) {
43522       {
43523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43524       };
43525     }
43526   }
43527 }
43528
43529
43530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43531   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43532
43533   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43534   {
43535     try {
43536       delete arg1;
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43548       };
43549     }
43550   }
43551 }
43552
43553
43554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43555   void * jresult ;
43556   Dali::Rect< int > *result = 0 ;
43557
43558   {
43559     try {
43560       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43561     } catch (std::out_of_range& e) {
43562       {
43563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43564       };
43565     } catch (std::exception& e) {
43566       {
43567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43568       };
43569     } catch (...) {
43570       {
43571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43572       };
43573     }
43574   }
43575   jresult = (void *)result;
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43581   void * jresult ;
43582   int arg1 ;
43583   int arg2 ;
43584   int arg3 ;
43585   int arg4 ;
43586   Dali::Rect< int > *result = 0 ;
43587
43588   arg1 = (int)jarg1;
43589   arg2 = (int)jarg2;
43590   arg3 = (int)jarg3;
43591   arg4 = (int)jarg4;
43592   {
43593     try {
43594       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43595     } catch (std::out_of_range& e) {
43596       {
43597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43598       };
43599     } catch (std::exception& e) {
43600       {
43601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43602       };
43603     } catch (...) {
43604       {
43605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43606       };
43607     }
43608   }
43609   jresult = (void *)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43615   void * jresult ;
43616   Dali::Rect< int > *arg1 = 0 ;
43617   Dali::Rect< int > *result = 0 ;
43618
43619   arg1 = (Dali::Rect< int > *)jarg1;
43620   if (!arg1) {
43621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43622     return 0;
43623   }
43624   {
43625     try {
43626       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43627     } catch (std::out_of_range& e) {
43628       {
43629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (std::exception& e) {
43632       {
43633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43647   void * jresult ;
43648   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43649   Dali::Rect< int > *arg2 = 0 ;
43650   Dali::Rect< int > *result = 0 ;
43651
43652   arg1 = (Dali::Rect< int > *)jarg1;
43653   arg2 = (Dali::Rect< int > *)jarg2;
43654   if (!arg2) {
43655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43656     return 0;
43657   }
43658   {
43659     try {
43660       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43661     } catch (std::out_of_range& e) {
43662       {
43663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43664       };
43665     } catch (std::exception& e) {
43666       {
43667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43668       };
43669     } catch (...) {
43670       {
43671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43672       };
43673     }
43674   }
43675   jresult = (void *)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43681   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43682   int arg2 ;
43683   int arg3 ;
43684   int arg4 ;
43685   int arg5 ;
43686
43687   arg1 = (Dali::Rect< int > *)jarg1;
43688   arg2 = (int)jarg2;
43689   arg3 = (int)jarg3;
43690   arg4 = (int)jarg4;
43691   arg5 = (int)jarg5;
43692   {
43693     try {
43694       (arg1)->Set(arg2,arg3,arg4,arg5);
43695     } catch (std::out_of_range& e) {
43696       {
43697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43698       };
43699     } catch (std::exception& e) {
43700       {
43701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43702       };
43703     } catch (...) {
43704       {
43705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43706       };
43707     }
43708   }
43709 }
43710
43711
43712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43713   unsigned int jresult ;
43714   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43715   bool result;
43716
43717   arg1 = (Dali::Rect< int > *)jarg1;
43718   {
43719     try {
43720       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43721     } catch (std::out_of_range& e) {
43722       {
43723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (std::exception& e) {
43726       {
43727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43732       };
43733     }
43734   }
43735   jresult = result;
43736   return jresult;
43737 }
43738
43739
43740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43741   int jresult ;
43742   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43743   int result;
43744
43745   arg1 = (Dali::Rect< int > *)jarg1;
43746   {
43747     try {
43748       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43749     } catch (std::out_of_range& e) {
43750       {
43751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43752       };
43753     } catch (std::exception& e) {
43754       {
43755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43760       };
43761     }
43762   }
43763   jresult = result;
43764   return jresult;
43765 }
43766
43767
43768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43769   int jresult ;
43770   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43771   int result;
43772
43773   arg1 = (Dali::Rect< int > *)jarg1;
43774   {
43775     try {
43776       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43777     } catch (std::out_of_range& e) {
43778       {
43779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43780       };
43781     } catch (std::exception& e) {
43782       {
43783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43784       };
43785     } catch (...) {
43786       {
43787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43788       };
43789     }
43790   }
43791   jresult = result;
43792   return jresult;
43793 }
43794
43795
43796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43797   int jresult ;
43798   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43799   int result;
43800
43801   arg1 = (Dali::Rect< int > *)jarg1;
43802   {
43803     try {
43804       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43805     } catch (std::out_of_range& e) {
43806       {
43807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43808       };
43809     } catch (std::exception& e) {
43810       {
43811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43812       };
43813     } catch (...) {
43814       {
43815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43816       };
43817     }
43818   }
43819   jresult = result;
43820   return jresult;
43821 }
43822
43823
43824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43825   int jresult ;
43826   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43827   int result;
43828
43829   arg1 = (Dali::Rect< int > *)jarg1;
43830   {
43831     try {
43832       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43833     } catch (std::out_of_range& e) {
43834       {
43835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43836       };
43837     } catch (std::exception& e) {
43838       {
43839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43840       };
43841     } catch (...) {
43842       {
43843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43844       };
43845     }
43846   }
43847   jresult = result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43853   int jresult ;
43854   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43855   int result;
43856
43857   arg1 = (Dali::Rect< int > *)jarg1;
43858   {
43859     try {
43860       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43861     } catch (std::out_of_range& e) {
43862       {
43863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43864       };
43865     } catch (std::exception& e) {
43866       {
43867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43872       };
43873     }
43874   }
43875   jresult = result;
43876   return jresult;
43877 }
43878
43879
43880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43881   unsigned int jresult ;
43882   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43883   Dali::Rect< int > *arg2 = 0 ;
43884   bool result;
43885
43886   arg1 = (Dali::Rect< int > *)jarg1;
43887   arg2 = (Dali::Rect< int > *)jarg2;
43888   if (!arg2) {
43889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43890     return 0;
43891   }
43892   {
43893     try {
43894       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43895     } catch (std::out_of_range& e) {
43896       {
43897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43898       };
43899     } catch (std::exception& e) {
43900       {
43901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43902       };
43903     } catch (...) {
43904       {
43905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43906       };
43907     }
43908   }
43909   jresult = result;
43910   return jresult;
43911 }
43912
43913
43914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43915   unsigned int jresult ;
43916   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43917   Dali::Rect< int > *arg2 = 0 ;
43918   bool result;
43919
43920   arg1 = (Dali::Rect< int > *)jarg1;
43921   arg2 = (Dali::Rect< int > *)jarg2;
43922   if (!arg2) {
43923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43924     return 0;
43925   }
43926   {
43927     try {
43928       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43929     } catch (std::out_of_range& e) {
43930       {
43931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43932       };
43933     } catch (std::exception& e) {
43934       {
43935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43936       };
43937     } catch (...) {
43938       {
43939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43940       };
43941     }
43942   }
43943   jresult = result;
43944   return jresult;
43945 }
43946
43947
43948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43949   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43950   int arg2 ;
43951
43952   arg1 = (Dali::Rect< int > *)jarg1;
43953   arg2 = (int)jarg2;
43954   if (arg1) (arg1)->x = arg2;
43955 }
43956
43957
43958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43959   int jresult ;
43960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43961   int result;
43962
43963   arg1 = (Dali::Rect< int > *)jarg1;
43964   result = (int) ((arg1)->x);
43965   jresult = result;
43966   return jresult;
43967 }
43968
43969
43970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43971   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43972   int arg2 ;
43973
43974   arg1 = (Dali::Rect< int > *)jarg1;
43975   arg2 = (int)jarg2;
43976   if (arg1) (arg1)->left = arg2;
43977 }
43978
43979
43980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43981   int jresult ;
43982   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43983   int result;
43984
43985   arg1 = (Dali::Rect< int > *)jarg1;
43986   result = (int) ((arg1)->left);
43987   jresult = result;
43988   return jresult;
43989 }
43990
43991
43992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43993   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43994   int arg2 ;
43995
43996   arg1 = (Dali::Rect< int > *)jarg1;
43997   arg2 = (int)jarg2;
43998   if (arg1) (arg1)->y = arg2;
43999 }
44000
44001
44002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44003   int jresult ;
44004   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44005   int result;
44006
44007   arg1 = (Dali::Rect< int > *)jarg1;
44008   result = (int) ((arg1)->y);
44009   jresult = result;
44010   return jresult;
44011 }
44012
44013
44014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44015   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44016   int arg2 ;
44017
44018   arg1 = (Dali::Rect< int > *)jarg1;
44019   arg2 = (int)jarg2;
44020   if (arg1) (arg1)->right = arg2;
44021 }
44022
44023
44024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44025   int jresult ;
44026   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44027   int result;
44028
44029   arg1 = (Dali::Rect< int > *)jarg1;
44030   result = (int) ((arg1)->right);
44031   jresult = result;
44032   return jresult;
44033 }
44034
44035
44036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44037   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44038   int arg2 ;
44039
44040   arg1 = (Dali::Rect< int > *)jarg1;
44041   arg2 = (int)jarg2;
44042   if (arg1) (arg1)->width = arg2;
44043 }
44044
44045
44046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44047   int jresult ;
44048   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44049   int result;
44050
44051   arg1 = (Dali::Rect< int > *)jarg1;
44052   result = (int) ((arg1)->width);
44053   jresult = result;
44054   return jresult;
44055 }
44056
44057
44058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44060   int arg2 ;
44061
44062   arg1 = (Dali::Rect< int > *)jarg1;
44063   arg2 = (int)jarg2;
44064   if (arg1) (arg1)->bottom = arg2;
44065 }
44066
44067
44068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44069   int jresult ;
44070   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44071   int result;
44072
44073   arg1 = (Dali::Rect< int > *)jarg1;
44074   result = (int) ((arg1)->bottom);
44075   jresult = result;
44076   return jresult;
44077 }
44078
44079
44080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44081   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44082   int arg2 ;
44083
44084   arg1 = (Dali::Rect< int > *)jarg1;
44085   arg2 = (int)jarg2;
44086   if (arg1) (arg1)->height = arg2;
44087 }
44088
44089
44090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44091   int jresult ;
44092   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44093   int result;
44094
44095   arg1 = (Dali::Rect< int > *)jarg1;
44096   result = (int) ((arg1)->height);
44097   jresult = result;
44098   return jresult;
44099 }
44100
44101
44102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44103   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44104   int arg2 ;
44105
44106   arg1 = (Dali::Rect< int > *)jarg1;
44107   arg2 = (int)jarg2;
44108   if (arg1) (arg1)->top = arg2;
44109 }
44110
44111
44112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44113   int jresult ;
44114   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44115   int result;
44116
44117   arg1 = (Dali::Rect< int > *)jarg1;
44118   result = (int) ((arg1)->top);
44119   jresult = result;
44120   return jresult;
44121 }
44122
44123
44124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44125   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44126
44127   arg1 = (Dali::Rect< int > *)jarg1;
44128   {
44129     try {
44130       delete arg1;
44131     } catch (std::out_of_range& e) {
44132       {
44133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44134       };
44135     } catch (std::exception& e) {
44136       {
44137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44138       };
44139     } catch (...) {
44140       {
44141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44142       };
44143     }
44144   }
44145 }
44146
44147
44148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44149   void * jresult ;
44150   Dali::Rect< float > *result = 0 ;
44151
44152   {
44153     try {
44154       result = (Dali::Rect< float > *)new Dali::Rect< float >();
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169   jresult = (void *)result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44175   void * jresult ;
44176   float arg1 ;
44177   float arg2 ;
44178   float arg3 ;
44179   float arg4 ;
44180   Dali::Rect< float > *result = 0 ;
44181
44182   arg1 = (float)jarg1;
44183   arg2 = (float)jarg2;
44184   arg3 = (float)jarg4;
44185   arg4 = (float)jarg3;
44186   {
44187     try {
44188       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
44189     } catch (std::out_of_range& e) {
44190       {
44191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44192       };
44193     } catch (std::exception& e) {
44194       {
44195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44196       };
44197     } catch (...) {
44198       {
44199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44200       };
44201     }
44202   }
44203   jresult = (void *)result;
44204   return jresult;
44205 }
44206
44207
44208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
44209   void * jresult ;
44210   Dali::Rect< float > *arg1 = 0 ;
44211   Dali::Rect< float > *result = 0 ;
44212
44213   arg1 = (Dali::Rect< float > *)jarg1;
44214   if (!arg1) {
44215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44216     return 0;
44217   }
44218   {
44219     try {
44220       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
44221     } catch (std::out_of_range& e) {
44222       {
44223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44224       };
44225     } catch (std::exception& e) {
44226       {
44227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44228       };
44229     } catch (...) {
44230       {
44231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44232       };
44233     }
44234   }
44235   jresult = (void *)result;
44236   return jresult;
44237 }
44238
44239
44240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
44241   void * jresult ;
44242   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44243   Dali::Rect< float > *arg2 = 0 ;
44244   Dali::Rect< float > *result = 0 ;
44245
44246   arg1 = (Dali::Rect< float > *)jarg1;
44247   arg2 = (Dali::Rect< float > *)jarg2;
44248   if (!arg2) {
44249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44250     return 0;
44251   }
44252   {
44253     try {
44254       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
44255     } catch (std::out_of_range& e) {
44256       {
44257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44258       };
44259     } catch (std::exception& e) {
44260       {
44261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44262       };
44263     } catch (...) {
44264       {
44265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44266       };
44267     }
44268   }
44269   jresult = (void *)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44275   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44276   float arg2 ;
44277   float arg3 ;
44278   float arg4 ;
44279   float arg5 ;
44280
44281   arg1 = (Dali::Rect< float > *)jarg1;
44282   arg2 = (float)jarg2;
44283   arg3 = (float)jarg3;
44284   arg4 = (float)jarg5;
44285   arg5 = (float)jarg4;
44286   {
44287     try {
44288       (arg1)->Set(arg2,arg3,arg4,arg5);
44289     } catch (std::out_of_range& e) {
44290       {
44291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44292       };
44293     } catch (std::exception& e) {
44294       {
44295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44296       };
44297     } catch (...) {
44298       {
44299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44300       };
44301     }
44302   }
44303 }
44304
44305
44306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
44307   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44308   float arg2 ;
44309
44310   arg1 = (Dali::Rect< float > *)jarg1;
44311   arg2 = (float)jarg2;
44312   if (arg1) (arg1)->left = arg2;
44313 }
44314
44315
44316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
44317   float jresult ;
44318   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44319   float result;
44320
44321   arg1 = (Dali::Rect< float > *)jarg1;
44322   result = (float) ((arg1)->left);
44323   jresult = result;
44324   return jresult;
44325 }
44326
44327
44328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
44329   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44330   float arg2 ;
44331
44332   arg1 = (Dali::Rect< float > *)jarg1;
44333   arg2 = (float)jarg2;
44334   if (arg1) (arg1)->left = arg2;
44335 }
44336
44337
44338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
44339   float jresult ;
44340   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44341   float result;
44342
44343   arg1 = (Dali::Rect< float > *)jarg1;
44344   result = (float) ((arg1)->left);
44345   jresult = result;
44346   return jresult;
44347 }
44348
44349
44350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
44351   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44352   float arg2 ;
44353
44354   arg1 = (Dali::Rect< float > *)jarg1;
44355   arg2 = (float)jarg2;
44356   if (arg1) (arg1)->right = arg2;
44357 }
44358
44359
44360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
44361   float jresult ;
44362   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44363   float result;
44364
44365   arg1 = (Dali::Rect< float > *)jarg1;
44366   result = (float) ((arg1)->right);
44367   jresult = result;
44368   return jresult;
44369 }
44370
44371
44372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
44373   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44374   float arg2 ;
44375
44376   arg1 = (Dali::Rect< float > *)jarg1;
44377   arg2 = (float)jarg2;
44378   if (arg1) (arg1)->right = arg2;
44379 }
44380
44381
44382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
44383   float jresult ;
44384   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44385   float result;
44386
44387   arg1 = (Dali::Rect< float > *)jarg1;
44388   result = (float) ((arg1)->right);
44389   jresult = result;
44390   return jresult;
44391 }
44392
44393
44394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
44395   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44396   float arg2 ;
44397
44398   arg1 = (Dali::Rect< float > *)jarg1;
44399   arg2 = (float)jarg2;
44400   if (arg1) (arg1)->bottom = arg2;
44401 }
44402
44403
44404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
44405   float jresult ;
44406   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44407   float result;
44408
44409   arg1 = (Dali::Rect< float > *)jarg1;
44410   result = (float) ((arg1)->bottom);
44411   jresult = result;
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44417   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44418   float arg2 ;
44419
44420   arg1 = (Dali::Rect< float > *)jarg1;
44421   arg2 = (float)jarg2;
44422   if (arg1) (arg1)->top = arg2;
44423 }
44424
44425
44426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44427   float jresult ;
44428   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44429   float result;
44430
44431   arg1 = (Dali::Rect< float > *)jarg1;
44432   result = (float) ((arg1)->top);
44433   jresult = result;
44434   return jresult;
44435 }
44436
44437
44438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44439   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44440
44441   arg1 = (Dali::Rect< float > *)jarg1;
44442   {
44443     try {
44444       delete arg1;
44445     } catch (std::out_of_range& e) {
44446       {
44447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44448       };
44449     } catch (std::exception& e) {
44450       {
44451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44452       };
44453     } catch (...) {
44454       {
44455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44456       };
44457     }
44458   }
44459 }
44460
44461
44462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44463   int jresult ;
44464   int result;
44465
44466   result = (int)Dali::Vector< int >::BaseType;
44467   jresult = (int)result;
44468   return jresult;
44469 }
44470
44471
44472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44473   void * jresult ;
44474   Dali::Vector< int > *result = 0 ;
44475
44476   {
44477     try {
44478       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44479     } catch (std::out_of_range& e) {
44480       {
44481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44482       };
44483     } catch (std::exception& e) {
44484       {
44485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44486       };
44487     } catch (...) {
44488       {
44489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44490       };
44491     }
44492   }
44493   jresult = (void *)result;
44494   return jresult;
44495 }
44496
44497
44498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44499   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44500
44501   arg1 = (Dali::Vector< int > *)jarg1;
44502   {
44503     try {
44504       delete arg1;
44505     } catch (std::out_of_range& e) {
44506       {
44507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44508       };
44509     } catch (std::exception& e) {
44510       {
44511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44512       };
44513     } catch (...) {
44514       {
44515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44516       };
44517     }
44518   }
44519 }
44520
44521
44522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44523   void * jresult ;
44524   Dali::Vector< int > *arg1 = 0 ;
44525   Dali::Vector< int > *result = 0 ;
44526
44527   arg1 = (Dali::Vector< int > *)jarg1;
44528   if (!arg1) {
44529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44530     return 0;
44531   }
44532   {
44533     try {
44534       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44535     } catch (std::out_of_range& e) {
44536       {
44537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44538       };
44539     } catch (std::exception& e) {
44540       {
44541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44542       };
44543     } catch (...) {
44544       {
44545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44546       };
44547     }
44548   }
44549   jresult = (void *)result;
44550   return jresult;
44551 }
44552
44553
44554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44555   void * jresult ;
44556   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44557   Dali::Vector< int > *arg2 = 0 ;
44558   Dali::Vector< int > *result = 0 ;
44559
44560   arg1 = (Dali::Vector< int > *)jarg1;
44561   arg2 = (Dali::Vector< int > *)jarg2;
44562   if (!arg2) {
44563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44564     return 0;
44565   }
44566   {
44567     try {
44568       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44569     } catch (std::out_of_range& e) {
44570       {
44571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (std::exception& e) {
44574       {
44575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (...) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44580       };
44581     }
44582   }
44583   jresult = (void *)result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44589   void * jresult ;
44590   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44591   Dali::Vector< int >::Iterator result;
44592
44593   arg1 = (Dali::Vector< int > *)jarg1;
44594   {
44595     try {
44596       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44597     } catch (std::out_of_range& e) {
44598       {
44599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44600       };
44601     } catch (std::exception& e) {
44602       {
44603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44604       };
44605     } catch (...) {
44606       {
44607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44608       };
44609     }
44610   }
44611   jresult = (void *)result;
44612   return jresult;
44613 }
44614
44615
44616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44617   void * jresult ;
44618   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44619   Dali::Vector< int >::Iterator result;
44620
44621   arg1 = (Dali::Vector< int > *)jarg1;
44622   {
44623     try {
44624       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44625     } catch (std::out_of_range& e) {
44626       {
44627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44628       };
44629     } catch (std::exception& e) {
44630       {
44631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (...) {
44634       {
44635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44636       };
44637     }
44638   }
44639   jresult = (void *)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44645   void * jresult ;
44646   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44647   Dali::Vector< int >::SizeType arg2 ;
44648   Dali::Vector< int >::ItemType *result = 0 ;
44649
44650   arg1 = (Dali::Vector< int > *)jarg1;
44651   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44652   {
44653     try {
44654       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (...) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44666       };
44667     }
44668   }
44669   jresult = (void *)result;
44670   return jresult;
44671 }
44672
44673
44674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44675   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44676   Dali::Vector< int >::ItemType *arg2 = 0 ;
44677   Dali::Vector< int >::ItemType temp2 ;
44678
44679   arg1 = (Dali::Vector< int > *)jarg1;
44680   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44681   arg2 = &temp2;
44682   {
44683     try {
44684       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44685     } catch (std::out_of_range& e) {
44686       {
44687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44688       };
44689     } catch (std::exception& e) {
44690       {
44691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44692       };
44693     } catch (...) {
44694       {
44695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44696       };
44697     }
44698   }
44699 }
44700
44701
44702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44703   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44704   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44705   Dali::Vector< int >::ItemType *arg3 = 0 ;
44706   Dali::Vector< int >::ItemType temp3 ;
44707
44708   arg1 = (Dali::Vector< int > *)jarg1;
44709   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44710   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44711   arg3 = &temp3;
44712   {
44713     try {
44714       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44715     } catch (std::out_of_range& e) {
44716       {
44717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44718       };
44719     } catch (std::exception& e) {
44720       {
44721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44722       };
44723     } catch (...) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44726       };
44727     }
44728   }
44729 }
44730
44731
44732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44733   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44734   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44735   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44736   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44737
44738   arg1 = (Dali::Vector< int > *)jarg1;
44739   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44740   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44741   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44742   {
44743     try {
44744       (arg1)->Insert(arg2,arg3,arg4);
44745     } catch (std::out_of_range& e) {
44746       {
44747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44748       };
44749     } catch (std::exception& e) {
44750       {
44751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44752       };
44753     } catch (...) {
44754       {
44755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44756       };
44757     }
44758   }
44759 }
44760
44761
44762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44763   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44764   Dali::Vector< int >::SizeType arg2 ;
44765
44766   arg1 = (Dali::Vector< int > *)jarg1;
44767   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44768   {
44769     try {
44770       (arg1)->Reserve(arg2);
44771     } catch (std::out_of_range& e) {
44772       {
44773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44774       };
44775     } catch (std::exception& e) {
44776       {
44777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44778       };
44779     } catch (...) {
44780       {
44781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44782       };
44783     }
44784   }
44785 }
44786
44787
44788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44789   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44790   Dali::Vector< int >::SizeType arg2 ;
44791
44792   arg1 = (Dali::Vector< int > *)jarg1;
44793   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44794   {
44795     try {
44796       (arg1)->Resize(arg2);
44797     } catch (std::out_of_range& e) {
44798       {
44799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44800       };
44801     } catch (std::exception& e) {
44802       {
44803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44804       };
44805     } catch (...) {
44806       {
44807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44808       };
44809     }
44810   }
44811 }
44812
44813
44814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44815   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44816   Dali::Vector< int >::SizeType arg2 ;
44817   Dali::Vector< int >::ItemType *arg3 = 0 ;
44818   Dali::Vector< int >::ItemType temp3 ;
44819
44820   arg1 = (Dali::Vector< int > *)jarg1;
44821   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44822   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44823   arg3 = &temp3;
44824   {
44825     try {
44826       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44827     } catch (std::out_of_range& e) {
44828       {
44829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44830       };
44831     } catch (std::exception& e) {
44832       {
44833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44834       };
44835     } catch (...) {
44836       {
44837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44838       };
44839     }
44840   }
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44845   void * jresult ;
44846   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44847   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44848   Dali::Vector< int >::Iterator result;
44849
44850   arg1 = (Dali::Vector< int > *)jarg1;
44851   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44852   {
44853     try {
44854       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44855     } catch (std::out_of_range& e) {
44856       {
44857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (std::exception& e) {
44860       {
44861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869   jresult = (void *)result;
44870   return jresult;
44871 }
44872
44873
44874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44875   void * jresult ;
44876   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44877   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44878   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44879   Dali::Vector< int >::Iterator result;
44880
44881   arg1 = (Dali::Vector< int > *)jarg1;
44882   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44883   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44884   {
44885     try {
44886       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44887     } catch (std::out_of_range& e) {
44888       {
44889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44890       };
44891     } catch (std::exception& e) {
44892       {
44893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44894       };
44895     } catch (...) {
44896       {
44897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44898       };
44899     }
44900   }
44901   jresult = (void *)result;
44902   return jresult;
44903 }
44904
44905
44906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44907   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44908   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44909
44910   arg1 = (Dali::Vector< int > *)jarg1;
44911   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44912   {
44913     try {
44914       (arg1)->Remove(arg2);
44915     } catch (std::out_of_range& e) {
44916       {
44917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44918       };
44919     } catch (std::exception& e) {
44920       {
44921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44922       };
44923     } catch (...) {
44924       {
44925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44926       };
44927     }
44928   }
44929 }
44930
44931
44932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44933   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44934   Dali::Vector< int > *arg2 = 0 ;
44935
44936   arg1 = (Dali::Vector< int > *)jarg1;
44937   arg2 = (Dali::Vector< int > *)jarg2;
44938   if (!arg2) {
44939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44940     return ;
44941   }
44942   {
44943     try {
44944       (arg1)->Swap(*arg2);
44945     } catch (std::out_of_range& e) {
44946       {
44947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44948       };
44949     } catch (std::exception& e) {
44950       {
44951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (...) {
44954       {
44955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44956       };
44957     }
44958   }
44959 }
44960
44961
44962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
44963   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44964
44965   arg1 = (Dali::Vector< int > *)jarg1;
44966   {
44967     try {
44968       (arg1)->Clear();
44969     } catch (std::out_of_range& e) {
44970       {
44971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44972       };
44973     } catch (std::exception& e) {
44974       {
44975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44976       };
44977     } catch (...) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44980       };
44981     }
44982   }
44983 }
44984
44985
44986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
44987   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44988
44989   arg1 = (Dali::Vector< int > *)jarg1;
44990   {
44991     try {
44992       (arg1)->Release();
44993     } catch (std::out_of_range& e) {
44994       {
44995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44996       };
44997     } catch (std::exception& e) {
44998       {
44999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45000       };
45001     } catch (...) {
45002       {
45003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45004       };
45005     }
45006   }
45007 }
45008
45009
45010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45011   int jresult ;
45012   int result;
45013
45014   result = (int)Dali::Vector< float >::BaseType;
45015   jresult = (int)result;
45016   return jresult;
45017 }
45018
45019
45020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45021   void * jresult ;
45022   Dali::Vector< float > *result = 0 ;
45023
45024   {
45025     try {
45026       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45027     } catch (std::out_of_range& e) {
45028       {
45029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45030       };
45031     } catch (std::exception& e) {
45032       {
45033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45034       };
45035     } catch (...) {
45036       {
45037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45038       };
45039     }
45040   }
45041   jresult = (void *)result;
45042   return jresult;
45043 }
45044
45045
45046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45047   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45048
45049   arg1 = (Dali::Vector< float > *)jarg1;
45050   {
45051     try {
45052       delete arg1;
45053     } catch (std::out_of_range& e) {
45054       {
45055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45056       };
45057     } catch (std::exception& e) {
45058       {
45059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45060       };
45061     } catch (...) {
45062       {
45063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45064       };
45065     }
45066   }
45067 }
45068
45069
45070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45071   void * jresult ;
45072   Dali::Vector< float > *arg1 = 0 ;
45073   Dali::Vector< float > *result = 0 ;
45074
45075   arg1 = (Dali::Vector< float > *)jarg1;
45076   if (!arg1) {
45077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45078     return 0;
45079   }
45080   {
45081     try {
45082       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45083     } catch (std::out_of_range& e) {
45084       {
45085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45086       };
45087     } catch (std::exception& e) {
45088       {
45089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45090       };
45091     } catch (...) {
45092       {
45093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45094       };
45095     }
45096   }
45097   jresult = (void *)result;
45098   return jresult;
45099 }
45100
45101
45102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45103   void * jresult ;
45104   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45105   Dali::Vector< float > *arg2 = 0 ;
45106   Dali::Vector< float > *result = 0 ;
45107
45108   arg1 = (Dali::Vector< float > *)jarg1;
45109   arg2 = (Dali::Vector< float > *)jarg2;
45110   if (!arg2) {
45111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45112     return 0;
45113   }
45114   {
45115     try {
45116       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45117     } catch (std::out_of_range& e) {
45118       {
45119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45120       };
45121     } catch (std::exception& e) {
45122       {
45123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (...) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45128       };
45129     }
45130   }
45131   jresult = (void *)result;
45132   return jresult;
45133 }
45134
45135
45136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45137   void * jresult ;
45138   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45139   Dali::Vector< float >::Iterator result;
45140
45141   arg1 = (Dali::Vector< float > *)jarg1;
45142   {
45143     try {
45144       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45145     } catch (std::out_of_range& e) {
45146       {
45147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45148       };
45149     } catch (std::exception& e) {
45150       {
45151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45152       };
45153     } catch (...) {
45154       {
45155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45156       };
45157     }
45158   }
45159   jresult = (void *)result;
45160   return jresult;
45161 }
45162
45163
45164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45165   void * jresult ;
45166   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45167   Dali::Vector< float >::Iterator result;
45168
45169   arg1 = (Dali::Vector< float > *)jarg1;
45170   {
45171     try {
45172       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45173     } catch (std::out_of_range& e) {
45174       {
45175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45176       };
45177     } catch (std::exception& e) {
45178       {
45179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45180       };
45181     } catch (...) {
45182       {
45183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45184       };
45185     }
45186   }
45187   jresult = (void *)result;
45188   return jresult;
45189 }
45190
45191
45192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45193   void * jresult ;
45194   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45195   Dali::Vector< float >::SizeType arg2 ;
45196   Dali::Vector< float >::ItemType *result = 0 ;
45197
45198   arg1 = (Dali::Vector< float > *)jarg1;
45199   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45200   {
45201     try {
45202       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45210       };
45211     } catch (...) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45214       };
45215     }
45216   }
45217   jresult = (void *)result;
45218   return jresult;
45219 }
45220
45221
45222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45223   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45224   Dali::Vector< float >::ItemType *arg2 = 0 ;
45225   Dali::Vector< float >::ItemType temp2 ;
45226
45227   arg1 = (Dali::Vector< float > *)jarg1;
45228   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45229   arg2 = &temp2;
45230   {
45231     try {
45232       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45233     } catch (std::out_of_range& e) {
45234       {
45235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45236       };
45237     } catch (std::exception& e) {
45238       {
45239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45240       };
45241     } catch (...) {
45242       {
45243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45244       };
45245     }
45246   }
45247 }
45248
45249
45250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45251   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45252   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45253   Dali::Vector< float >::ItemType *arg3 = 0 ;
45254   Dali::Vector< float >::ItemType temp3 ;
45255
45256   arg1 = (Dali::Vector< float > *)jarg1;
45257   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45258   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45259   arg3 = &temp3;
45260   {
45261     try {
45262       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45263     } catch (std::out_of_range& e) {
45264       {
45265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (std::exception& e) {
45268       {
45269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45270       };
45271     } catch (...) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45274       };
45275     }
45276   }
45277 }
45278
45279
45280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45282   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45283   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45284   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45285
45286   arg1 = (Dali::Vector< float > *)jarg1;
45287   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45288   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45289   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45290   {
45291     try {
45292       (arg1)->Insert(arg2,arg3,arg4);
45293     } catch (std::out_of_range& e) {
45294       {
45295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45296       };
45297     } catch (std::exception& e) {
45298       {
45299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45300       };
45301     } catch (...) {
45302       {
45303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45304       };
45305     }
45306   }
45307 }
45308
45309
45310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45311   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45312   Dali::Vector< float >::SizeType arg2 ;
45313
45314   arg1 = (Dali::Vector< float > *)jarg1;
45315   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45316   {
45317     try {
45318       (arg1)->Reserve(arg2);
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_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45337   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45338   Dali::Vector< float >::SizeType arg2 ;
45339
45340   arg1 = (Dali::Vector< float > *)jarg1;
45341   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45342   {
45343     try {
45344       (arg1)->Resize(arg2);
45345     } catch (std::out_of_range& e) {
45346       {
45347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45348       };
45349     } catch (std::exception& e) {
45350       {
45351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45352       };
45353     } catch (...) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45356       };
45357     }
45358   }
45359 }
45360
45361
45362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45363   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45364   Dali::Vector< float >::SizeType arg2 ;
45365   Dali::Vector< float >::ItemType *arg3 = 0 ;
45366   Dali::Vector< float >::ItemType temp3 ;
45367
45368   arg1 = (Dali::Vector< float > *)jarg1;
45369   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45370   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45371   arg3 = &temp3;
45372   {
45373     try {
45374       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45375     } catch (std::out_of_range& e) {
45376       {
45377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45378       };
45379     } catch (std::exception& e) {
45380       {
45381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45386       };
45387     }
45388   }
45389 }
45390
45391
45392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45393   void * jresult ;
45394   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45395   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45396   Dali::Vector< float >::Iterator result;
45397
45398   arg1 = (Dali::Vector< float > *)jarg1;
45399   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45400   {
45401     try {
45402       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45403     } catch (std::out_of_range& e) {
45404       {
45405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45406       };
45407     } catch (std::exception& e) {
45408       {
45409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (...) {
45412       {
45413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45414       };
45415     }
45416   }
45417   jresult = (void *)result;
45418   return jresult;
45419 }
45420
45421
45422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45423   void * jresult ;
45424   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45425   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45426   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45427   Dali::Vector< float >::Iterator result;
45428
45429   arg1 = (Dali::Vector< float > *)jarg1;
45430   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45431   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45432   {
45433     try {
45434       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45435     } catch (std::out_of_range& e) {
45436       {
45437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45438       };
45439     } catch (std::exception& e) {
45440       {
45441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45442       };
45443     } catch (...) {
45444       {
45445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45446       };
45447     }
45448   }
45449   jresult = (void *)result;
45450   return jresult;
45451 }
45452
45453
45454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45455   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45456   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45457
45458   arg1 = (Dali::Vector< float > *)jarg1;
45459   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45460   {
45461     try {
45462       (arg1)->Remove(arg2);
45463     } catch (std::out_of_range& e) {
45464       {
45465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45466       };
45467     } catch (std::exception& e) {
45468       {
45469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45470       };
45471     } catch (...) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45474       };
45475     }
45476   }
45477 }
45478
45479
45480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45481   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45482   Dali::Vector< float > *arg2 = 0 ;
45483
45484   arg1 = (Dali::Vector< float > *)jarg1;
45485   arg2 = (Dali::Vector< float > *)jarg2;
45486   if (!arg2) {
45487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45488     return ;
45489   }
45490   {
45491     try {
45492       (arg1)->Swap(*arg2);
45493     } catch (std::out_of_range& e) {
45494       {
45495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45496       };
45497     } catch (std::exception& e) {
45498       {
45499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45500       };
45501     } catch (...) {
45502       {
45503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45504       };
45505     }
45506   }
45507 }
45508
45509
45510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45511   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45512
45513   arg1 = (Dali::Vector< float > *)jarg1;
45514   {
45515     try {
45516       (arg1)->Clear();
45517     } catch (std::out_of_range& e) {
45518       {
45519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45520       };
45521     } catch (std::exception& e) {
45522       {
45523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45524       };
45525     } catch (...) {
45526       {
45527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45528       };
45529     }
45530   }
45531 }
45532
45533
45534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
45535   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45536
45537   arg1 = (Dali::Vector< float > *)jarg1;
45538   {
45539     try {
45540       (arg1)->Release();
45541     } catch (std::out_of_range& e) {
45542       {
45543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (std::exception& e) {
45546       {
45547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45552       };
45553     }
45554   }
45555 }
45556
45557
45558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45559   int jresult ;
45560   int result;
45561
45562   result = (int)Dali::Vector< unsigned char >::BaseType;
45563   jresult = (int)result;
45564   return jresult;
45565 }
45566
45567
45568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45569   void * jresult ;
45570   Dali::Vector< unsigned char > *result = 0 ;
45571
45572   {
45573     try {
45574       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45575     } catch (std::out_of_range& e) {
45576       {
45577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45578       };
45579     } catch (std::exception& e) {
45580       {
45581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45582       };
45583     } catch (...) {
45584       {
45585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45586       };
45587     }
45588   }
45589   jresult = (void *)result;
45590   return jresult;
45591 }
45592
45593
45594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45595   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45596
45597   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45598   {
45599     try {
45600       delete arg1;
45601     } catch (std::out_of_range& e) {
45602       {
45603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45604       };
45605     } catch (std::exception& e) {
45606       {
45607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45608       };
45609     } catch (...) {
45610       {
45611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45612       };
45613     }
45614   }
45615 }
45616
45617
45618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45619   void * jresult ;
45620   Dali::Vector< unsigned char > *arg1 = 0 ;
45621   Dali::Vector< unsigned char > *result = 0 ;
45622
45623   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45624   if (!arg1) {
45625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45626     return 0;
45627   }
45628   {
45629     try {
45630       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
45631     } catch (std::out_of_range& e) {
45632       {
45633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45634       };
45635     } catch (std::exception& e) {
45636       {
45637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45638       };
45639     } catch (...) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45642       };
45643     }
45644   }
45645   jresult = (void *)result;
45646   return jresult;
45647 }
45648
45649
45650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45651   void * jresult ;
45652   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45653   Dali::Vector< unsigned char > *arg2 = 0 ;
45654   Dali::Vector< unsigned char > *result = 0 ;
45655
45656   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45657   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45658   if (!arg2) {
45659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45660     return 0;
45661   }
45662   {
45663     try {
45664       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679   jresult = (void *)result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
45685   void * jresult ;
45686   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45687   Dali::Vector< unsigned char >::Iterator result;
45688
45689   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45690   {
45691     try {
45692       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45693     } catch (std::out_of_range& e) {
45694       {
45695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45696       };
45697     } catch (std::exception& e) {
45698       {
45699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45700       };
45701     } catch (...) {
45702       {
45703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45704       };
45705     }
45706   }
45707   jresult = (void *)result;
45708   return jresult;
45709 }
45710
45711
45712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45713   void * jresult ;
45714   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45715   Dali::Vector< unsigned char >::Iterator result;
45716
45717   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45718   {
45719     try {
45720       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45721     } catch (std::out_of_range& e) {
45722       {
45723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45724       };
45725     } catch (std::exception& e) {
45726       {
45727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45728       };
45729     } catch (...) {
45730       {
45731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45732       };
45733     }
45734   }
45735   jresult = (void *)result;
45736   return jresult;
45737 }
45738
45739
45740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45741   void * jresult ;
45742   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45743   Dali::Vector< unsigned char >::SizeType arg2 ;
45744   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45745
45746   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45747   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45748   {
45749     try {
45750       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45751     } catch (std::out_of_range& e) {
45752       {
45753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45754       };
45755     } catch (std::exception& e) {
45756       {
45757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (...) {
45760       {
45761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45762       };
45763     }
45764   }
45765   jresult = (void *)result;
45766   return jresult;
45767 }
45768
45769
45770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45771   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45772   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45773   Dali::Vector< unsigned char >::ItemType temp2 ;
45774
45775   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45776   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45777   arg2 = &temp2;
45778   {
45779     try {
45780       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45781     } catch (std::out_of_range& e) {
45782       {
45783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45784       };
45785     } catch (std::exception& e) {
45786       {
45787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45788       };
45789     } catch (...) {
45790       {
45791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45792       };
45793     }
45794   }
45795 }
45796
45797
45798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45799   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45800   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45801   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45802   Dali::Vector< unsigned char >::ItemType temp3 ;
45803
45804   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45805   arg2 = jarg2;
45806   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45807   arg3 = &temp3;
45808   {
45809     try {
45810       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45811     } catch (std::out_of_range& e) {
45812       {
45813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45814       };
45815     } catch (std::exception& e) {
45816       {
45817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45818       };
45819     } catch (...) {
45820       {
45821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45822       };
45823     }
45824   }
45825
45826
45827 }
45828
45829
45830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45831   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45832   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45833   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45834   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45835
45836   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45837   arg2 = jarg2;
45838   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45839   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45840   {
45841     try {
45842       (arg1)->Insert(arg2,arg3,arg4);
45843     } catch (std::out_of_range& e) {
45844       {
45845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45846       };
45847     } catch (std::exception& e) {
45848       {
45849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45850       };
45851     } catch (...) {
45852       {
45853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45854       };
45855     }
45856   }
45857
45858
45859 }
45860
45861
45862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45863   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45864   Dali::Vector< unsigned char >::SizeType arg2 ;
45865
45866   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45867   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45868   {
45869     try {
45870       (arg1)->Reserve(arg2);
45871     } catch (std::out_of_range& e) {
45872       {
45873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45874       };
45875     } catch (std::exception& e) {
45876       {
45877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45878       };
45879     } catch (...) {
45880       {
45881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45882       };
45883     }
45884   }
45885 }
45886
45887
45888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45889   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45890   Dali::Vector< unsigned char >::SizeType arg2 ;
45891
45892   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45893   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45894   {
45895     try {
45896       (arg1)->Resize(arg2);
45897     } catch (std::out_of_range& e) {
45898       {
45899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45900       };
45901     } catch (std::exception& e) {
45902       {
45903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45904       };
45905     } catch (...) {
45906       {
45907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45908       };
45909     }
45910   }
45911 }
45912
45913
45914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45915   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45916   Dali::Vector< unsigned char >::SizeType arg2 ;
45917   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45918   Dali::Vector< unsigned char >::ItemType temp3 ;
45919
45920   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45921   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45922   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45923   arg3 = &temp3;
45924   {
45925     try {
45926       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45927     } catch (std::out_of_range& e) {
45928       {
45929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45930       };
45931     } catch (std::exception& e) {
45932       {
45933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45934       };
45935     } catch (...) {
45936       {
45937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45938       };
45939     }
45940   }
45941 }
45942
45943
45944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45945   void * jresult ;
45946   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45947   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45948   Dali::Vector< unsigned char >::Iterator result;
45949
45950   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45951   arg2 = jarg2;
45952   {
45953     try {
45954       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45955     } catch (std::out_of_range& e) {
45956       {
45957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45958       };
45959     } catch (std::exception& e) {
45960       {
45961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45962       };
45963     } catch (...) {
45964       {
45965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45966       };
45967     }
45968   }
45969   jresult = (void *)result;
45970
45971
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
45977   void * jresult ;
45978   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45979   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45980   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45981   Dali::Vector< unsigned char >::Iterator result;
45982
45983   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45984   arg2 = jarg2;
45985   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45986   {
45987     try {
45988       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
45989     } catch (std::out_of_range& e) {
45990       {
45991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45992       };
45993     } catch (std::exception& e) {
45994       {
45995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45996       };
45997     } catch (...) {
45998       {
45999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46000       };
46001     }
46002   }
46003   jresult = (void *)result;
46004
46005
46006   return jresult;
46007 }
46008
46009
46010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46012   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46013
46014   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46015   arg2 = jarg2;
46016   {
46017     try {
46018       (arg1)->Remove(arg2);
46019     } catch (std::out_of_range& e) {
46020       {
46021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46022       };
46023     } catch (std::exception& e) {
46024       {
46025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46026       };
46027     } catch (...) {
46028       {
46029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46030       };
46031     }
46032   }
46033
46034
46035 }
46036
46037
46038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46039   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46040   Dali::Vector< unsigned char > *arg2 = 0 ;
46041
46042   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46043   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46044   if (!arg2) {
46045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46046     return ;
46047   }
46048   {
46049     try {
46050       (arg1)->Swap(*arg2);
46051     } catch (std::out_of_range& e) {
46052       {
46053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46054       };
46055     } catch (std::exception& e) {
46056       {
46057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46058       };
46059     } catch (...) {
46060       {
46061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46062       };
46063     }
46064   }
46065 }
46066
46067
46068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46069   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46070
46071   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46072   {
46073     try {
46074       (arg1)->Clear();
46075     } catch (std::out_of_range& e) {
46076       {
46077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46078       };
46079     } catch (std::exception& e) {
46080       {
46081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46082       };
46083     } catch (...) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46086       };
46087     }
46088   }
46089 }
46090
46091
46092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46093   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46094
46095   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46096   {
46097     try {
46098       (arg1)->Release();
46099     } catch (std::out_of_range& e) {
46100       {
46101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46102       };
46103     } catch (std::exception& e) {
46104       {
46105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46106       };
46107     } catch (...) {
46108       {
46109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46110       };
46111     }
46112   }
46113 }
46114
46115
46116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46117   int jresult ;
46118   int result;
46119
46120   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46121   jresult = (int)result;
46122   return jresult;
46123 }
46124
46125
46126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46127   void * jresult ;
46128   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46129
46130   {
46131     try {
46132       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46133     } catch (std::out_of_range& e) {
46134       {
46135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (std::exception& e) {
46138       {
46139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46140       };
46141     } catch (...) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46144       };
46145     }
46146   }
46147   jresult = (void *)result;
46148   return jresult;
46149 }
46150
46151
46152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46153   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46154
46155   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46156   {
46157     try {
46158       delete arg1;
46159     } catch (std::out_of_range& e) {
46160       {
46161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46162       };
46163     } catch (std::exception& e) {
46164       {
46165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46166       };
46167     } catch (...) {
46168       {
46169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46170       };
46171     }
46172   }
46173 }
46174
46175
46176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46177   void * jresult ;
46178   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46179   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46180
46181   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46182   if (!arg1) {
46183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46184     return 0;
46185   }
46186   {
46187     try {
46188       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46189     } catch (std::out_of_range& e) {
46190       {
46191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46192       };
46193     } catch (std::exception& e) {
46194       {
46195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (...) {
46198       {
46199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46200       };
46201     }
46202   }
46203   jresult = (void *)result;
46204   return jresult;
46205 }
46206
46207
46208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46209   void * jresult ;
46210   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46211   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46212   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46213
46214   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46215   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46216   if (!arg2) {
46217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46218     return 0;
46219   }
46220   {
46221     try {
46222       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46223     } catch (std::out_of_range& e) {
46224       {
46225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46226       };
46227     } catch (std::exception& e) {
46228       {
46229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46230       };
46231     } catch (...) {
46232       {
46233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46234       };
46235     }
46236   }
46237   jresult = (void *)result;
46238   return jresult;
46239 }
46240
46241
46242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46243   void * jresult ;
46244   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46245   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46246
46247   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46248   {
46249     try {
46250       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46251     } catch (std::out_of_range& e) {
46252       {
46253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46254       };
46255     } catch (std::exception& e) {
46256       {
46257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46258       };
46259     } catch (...) {
46260       {
46261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46262       };
46263     }
46264   }
46265   jresult = (void *)result;
46266   return jresult;
46267 }
46268
46269
46270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46271   void * jresult ;
46272   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46273   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46274
46275   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46276   {
46277     try {
46278       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
46279     } catch (std::out_of_range& e) {
46280       {
46281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46282       };
46283     } catch (std::exception& e) {
46284       {
46285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46286       };
46287     } catch (...) {
46288       {
46289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46290       };
46291     }
46292   }
46293   jresult = (void *)result;
46294   return jresult;
46295 }
46296
46297
46298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46299   void * jresult ;
46300   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46301   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46302   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46303
46304   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46305   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46306   {
46307     try {
46308       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46309     } catch (std::out_of_range& e) {
46310       {
46311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46312       };
46313     } catch (std::exception& e) {
46314       {
46315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46316       };
46317     } catch (...) {
46318       {
46319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46320       };
46321     }
46322   }
46323   jresult = (void *)result;
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46329   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46330   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46331
46332   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46333   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46334   if (!arg2) {
46335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46336     return ;
46337   }
46338   {
46339     try {
46340       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46341     } catch (std::out_of_range& e) {
46342       {
46343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46344       };
46345     } catch (std::exception& e) {
46346       {
46347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46348       };
46349     } catch (...) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46352       };
46353     }
46354   }
46355 }
46356
46357
46358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46359   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46360   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46361   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46362
46363   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46364   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46365   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46366   if (!arg3) {
46367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46368     return ;
46369   }
46370   {
46371     try {
46372       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46373     } catch (std::out_of_range& e) {
46374       {
46375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46376       };
46377     } catch (std::exception& e) {
46378       {
46379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46380       };
46381     } catch (...) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46384       };
46385     }
46386   }
46387 }
46388
46389
46390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46391   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46392   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46393   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46394   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46395
46396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46397   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46398   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46399   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46400   {
46401     try {
46402       (arg1)->Insert(arg2,arg3,arg4);
46403     } catch (std::out_of_range& e) {
46404       {
46405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46406       };
46407     } catch (std::exception& e) {
46408       {
46409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46414       };
46415     }
46416   }
46417 }
46418
46419
46420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46421   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46422   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46423
46424   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46425   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46426   {
46427     try {
46428       (arg1)->Reserve(arg2);
46429     } catch (std::out_of_range& e) {
46430       {
46431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46432       };
46433     } catch (std::exception& e) {
46434       {
46435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46436       };
46437     } catch (...) {
46438       {
46439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46440       };
46441     }
46442   }
46443 }
46444
46445
46446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46447   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46448   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46449
46450   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46451   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46452   {
46453     try {
46454       (arg1)->Resize(arg2);
46455     } catch (std::out_of_range& e) {
46456       {
46457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46458       };
46459     } catch (std::exception& e) {
46460       {
46461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46462       };
46463     } catch (...) {
46464       {
46465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46466       };
46467     }
46468   }
46469 }
46470
46471
46472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46473   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46474   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46475   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46476
46477   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46478   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46479   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46480   if (!arg3) {
46481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46482     return ;
46483   }
46484   {
46485     try {
46486       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46487     } catch (std::out_of_range& e) {
46488       {
46489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46490       };
46491     } catch (std::exception& e) {
46492       {
46493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46494       };
46495     } catch (...) {
46496       {
46497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46498       };
46499     }
46500   }
46501 }
46502
46503
46504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46505   void * jresult ;
46506   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46507   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46508   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46509
46510   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46511   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46512   {
46513     try {
46514       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46515     } catch (std::out_of_range& e) {
46516       {
46517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (std::exception& e) {
46520       {
46521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46526       };
46527     }
46528   }
46529   jresult = (void *)result;
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46535   void * jresult ;
46536   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46537   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46538   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46539   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46540
46541   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46542   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46543   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46544   {
46545     try {
46546       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
46547     } catch (std::out_of_range& e) {
46548       {
46549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46550       };
46551     } catch (std::exception& e) {
46552       {
46553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46554       };
46555     } catch (...) {
46556       {
46557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46558       };
46559     }
46560   }
46561   jresult = (void *)result;
46562   return jresult;
46563 }
46564
46565
46566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46567   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46568   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46569
46570   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46571   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46572   {
46573     try {
46574       (arg1)->Remove(arg2);
46575     } catch (std::out_of_range& e) {
46576       {
46577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46578       };
46579     } catch (std::exception& e) {
46580       {
46581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46582       };
46583     } catch (...) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46586       };
46587     }
46588   }
46589 }
46590
46591
46592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46593   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46594   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46595
46596   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46597   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46598   if (!arg2) {
46599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46600     return ;
46601   }
46602   {
46603     try {
46604       (arg1)->Swap(*arg2);
46605     } catch (std::out_of_range& e) {
46606       {
46607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46608       };
46609     } catch (std::exception& e) {
46610       {
46611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46612       };
46613     } catch (...) {
46614       {
46615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46616       };
46617     }
46618   }
46619 }
46620
46621
46622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46623   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46624
46625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46626   {
46627     try {
46628       (arg1)->Clear();
46629     } catch (std::out_of_range& e) {
46630       {
46631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46632       };
46633     } catch (std::exception& e) {
46634       {
46635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46636       };
46637     } catch (...) {
46638       {
46639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46640       };
46641     }
46642   }
46643 }
46644
46645
46646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46647   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46648
46649   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46650   {
46651     try {
46652       (arg1)->Release();
46653     } catch (std::out_of_range& e) {
46654       {
46655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46656       };
46657     } catch (std::exception& e) {
46658       {
46659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46660       };
46661     } catch (...) {
46662       {
46663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46664       };
46665     }
46666   }
46667 }
46668
46669
46670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46671   void * jresult ;
46672   Dali::Signal< void () > *result = 0 ;
46673
46674   {
46675     try {
46676       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46677     } catch (std::out_of_range& e) {
46678       {
46679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46680       };
46681     } catch (std::exception& e) {
46682       {
46683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46684       };
46685     } catch (...) {
46686       {
46687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46688       };
46689     }
46690   }
46691   jresult = (void *)result;
46692   return jresult;
46693 }
46694
46695
46696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46697   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46698
46699   arg1 = (Dali::Signal< void () > *)jarg1;
46700   {
46701     try {
46702       delete arg1;
46703     } catch (std::out_of_range& e) {
46704       {
46705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (std::exception& e) {
46708       {
46709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46714       };
46715     }
46716   }
46717 }
46718
46719
46720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46721   unsigned int jresult ;
46722   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46723   bool result;
46724
46725   arg1 = (Dali::Signal< void () > *)jarg1;
46726   {
46727     try {
46728       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46729     } catch (std::out_of_range& e) {
46730       {
46731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46732       };
46733     } catch (std::exception& e) {
46734       {
46735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46736       };
46737     } catch (...) {
46738       {
46739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46740       };
46741     }
46742   }
46743   jresult = result;
46744   return jresult;
46745 }
46746
46747
46748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46749   unsigned long jresult ;
46750   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46751   std::size_t result;
46752
46753   arg1 = (Dali::Signal< void () > *)jarg1;
46754   {
46755     try {
46756       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46757     } catch (std::out_of_range& e) {
46758       {
46759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46760       };
46761     } catch (std::exception& e) {
46762       {
46763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46764       };
46765     } catch (...) {
46766       {
46767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46768       };
46769     }
46770   }
46771   jresult = (unsigned long)result;
46772   return jresult;
46773 }
46774
46775
46776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46777   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46778   void (*arg2)() = (void (*)()) 0 ;
46779
46780   arg1 = (Dali::Signal< void () > *)jarg1;
46781   arg2 = (void (*)())jarg2;
46782   {
46783     try {
46784       (arg1)->Connect(arg2);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46792       };
46793     } catch (...) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46796       };
46797     }
46798   }
46799 }
46800
46801
46802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46803   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46804   void (*arg2)() = (void (*)()) 0 ;
46805
46806   arg1 = (Dali::Signal< void () > *)jarg1;
46807   arg2 = (void (*)())jarg2;
46808   {
46809     try {
46810       (arg1)->Disconnect(arg2);
46811     } catch (std::out_of_range& e) {
46812       {
46813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46814       };
46815     } catch (std::exception& e) {
46816       {
46817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46818       };
46819     } catch (...) {
46820       {
46821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46822       };
46823     }
46824   }
46825 }
46826
46827
46828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46829   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46830   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46831   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46832
46833   arg1 = (Dali::Signal< void () > *)jarg1;
46834   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46835   arg3 = (Dali::FunctorDelegate *)jarg3;
46836   {
46837     try {
46838       (arg1)->Connect(arg2,arg3);
46839     } catch (std::out_of_range& e) {
46840       {
46841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46842       };
46843     } catch (std::exception& e) {
46844       {
46845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46846       };
46847     } catch (...) {
46848       {
46849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46850       };
46851     }
46852   }
46853 }
46854
46855
46856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
46857   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46858
46859   arg1 = (Dali::Signal< void () > *)jarg1;
46860   {
46861     try {
46862       (arg1)->Emit();
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (...) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46874       };
46875     }
46876   }
46877 }
46878
46879
46880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46881   unsigned int jresult ;
46882   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46883   bool result;
46884
46885   arg1 = (Dali::Signal< void (float) > *)jarg1;
46886   {
46887     try {
46888       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46889     } catch (std::out_of_range& e) {
46890       {
46891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46892       };
46893     } catch (std::exception& e) {
46894       {
46895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (...) {
46898       {
46899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46900       };
46901     }
46902   }
46903   jresult = result;
46904   return jresult;
46905 }
46906
46907
46908 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46909   unsigned long jresult ;
46910   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46911   std::size_t result;
46912
46913   arg1 = (Dali::Signal< void (float) > *)jarg1;
46914   {
46915     try {
46916       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46917     } catch (std::out_of_range& e) {
46918       {
46919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46920       };
46921     } catch (std::exception& e) {
46922       {
46923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46924       };
46925     } catch (...) {
46926       {
46927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46928       };
46929     }
46930   }
46931   jresult = (unsigned long)result;
46932   return jresult;
46933 }
46934
46935
46936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46937   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46938   void (*arg2)(float) = (void (*)(float)) 0 ;
46939
46940   arg1 = (Dali::Signal< void (float) > *)jarg1;
46941   arg2 = (void (*)(float))jarg2;
46942   {
46943     try {
46944       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46952       };
46953     } catch (...) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46956       };
46957     }
46958   }
46959 }
46960
46961
46962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
46963   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46964   void (*arg2)(float) = (void (*)(float)) 0 ;
46965
46966   arg1 = (Dali::Signal< void (float) > *)jarg1;
46967   arg2 = (void (*)(float))jarg2;
46968   {
46969     try {
46970       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
46971     } catch (std::out_of_range& e) {
46972       {
46973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46974       };
46975     } catch (std::exception& e) {
46976       {
46977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46978       };
46979     } catch (...) {
46980       {
46981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46982       };
46983     }
46984   }
46985 }
46986
46987
46988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
46989   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46990   float arg2 ;
46991
46992   arg1 = (Dali::Signal< void (float) > *)jarg1;
46993   arg2 = (float)jarg2;
46994   {
46995     try {
46996       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
46997     } catch (std::out_of_range& e) {
46998       {
46999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47000       };
47001     } catch (std::exception& e) {
47002       {
47003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47004       };
47005     } catch (...) {
47006       {
47007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47008       };
47009     }
47010   }
47011 }
47012
47013
47014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47015   void * jresult ;
47016   Dali::Signal< void (float) > *result = 0 ;
47017
47018   {
47019     try {
47020       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47021     } catch (std::out_of_range& e) {
47022       {
47023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (std::exception& e) {
47026       {
47027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47028       };
47029     } catch (...) {
47030       {
47031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47032       };
47033     }
47034   }
47035   jresult = (void *)result;
47036   return jresult;
47037 }
47038
47039
47040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47041   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47042
47043   arg1 = (Dali::Signal< void (float) > *)jarg1;
47044   {
47045     try {
47046       delete arg1;
47047     } catch (std::out_of_range& e) {
47048       {
47049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47050       };
47051     } catch (std::exception& e) {
47052       {
47053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47054       };
47055     } catch (...) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47058       };
47059     }
47060   }
47061 }
47062
47063
47064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47065   unsigned int jresult ;
47066   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47067   bool result;
47068
47069   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47070   {
47071     try {
47072       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47073     } catch (std::out_of_range& e) {
47074       {
47075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47076       };
47077     } catch (std::exception& e) {
47078       {
47079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47080       };
47081     } catch (...) {
47082       {
47083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47084       };
47085     }
47086   }
47087   jresult = result;
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47093   unsigned long jresult ;
47094   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47095   std::size_t result;
47096
47097   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47098   {
47099     try {
47100       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47101     } catch (std::out_of_range& e) {
47102       {
47103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (std::exception& e) {
47106       {
47107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (...) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47112       };
47113     }
47114   }
47115   jresult = (unsigned long)result;
47116   return jresult;
47117 }
47118
47119
47120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47121   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47122   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47123
47124   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47125   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47126   {
47127     try {
47128       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47129     } catch (std::out_of_range& e) {
47130       {
47131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47132       };
47133     } catch (std::exception& e) {
47134       {
47135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47136       };
47137     } catch (...) {
47138       {
47139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47140       };
47141     }
47142   }
47143 }
47144
47145
47146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47147   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47148   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47149
47150   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47151   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47152   {
47153     try {
47154       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47155     } catch (std::out_of_range& e) {
47156       {
47157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47158       };
47159     } catch (std::exception& e) {
47160       {
47161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47162       };
47163     } catch (...) {
47164       {
47165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47166       };
47167     }
47168   }
47169 }
47170
47171
47172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47174   Dali::BaseHandle arg2 ;
47175   Dali::BaseHandle *argp2 ;
47176
47177   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47178   argp2 = (Dali::BaseHandle *)jarg2;
47179   if (!argp2) {
47180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47181     return ;
47182   }
47183   arg2 = *argp2;
47184   {
47185     try {
47186       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47187     } catch (std::out_of_range& e) {
47188       {
47189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47190       };
47191     } catch (std::exception& e) {
47192       {
47193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47194       };
47195     } catch (...) {
47196       {
47197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47198       };
47199     }
47200   }
47201 }
47202
47203
47204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47205   void * jresult ;
47206   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47207
47208   {
47209     try {
47210       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47211     } catch (std::out_of_range& e) {
47212       {
47213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47214       };
47215     } catch (std::exception& e) {
47216       {
47217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47218       };
47219     } catch (...) {
47220       {
47221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47222       };
47223     }
47224   }
47225   jresult = (void *)result;
47226   return jresult;
47227 }
47228
47229
47230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47231   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47232
47233   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47234   {
47235     try {
47236       delete arg1;
47237     } catch (std::out_of_range& e) {
47238       {
47239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47240       };
47241     } catch (std::exception& e) {
47242       {
47243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47244       };
47245     } catch (...) {
47246       {
47247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47248       };
47249     }
47250   }
47251 }
47252
47253
47254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47255   unsigned int jresult ;
47256   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47257   bool result;
47258
47259   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47260   {
47261     try {
47262       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47263     } catch (std::out_of_range& e) {
47264       {
47265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47266       };
47267     } catch (std::exception& e) {
47268       {
47269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (...) {
47272       {
47273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47274       };
47275     }
47276   }
47277   jresult = result;
47278   return jresult;
47279 }
47280
47281
47282 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47283   unsigned long jresult ;
47284   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47285   std::size_t result;
47286
47287   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47288   {
47289     try {
47290       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47291     } catch (std::out_of_range& e) {
47292       {
47293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47294       };
47295     } catch (std::exception& e) {
47296       {
47297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47298       };
47299     } catch (...) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47302       };
47303     }
47304   }
47305   jresult = (unsigned long)result;
47306   return jresult;
47307 }
47308
47309
47310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47311   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47312   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47313
47314   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47315   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47316   {
47317     try {
47318       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47319     } catch (std::out_of_range& e) {
47320       {
47321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47322       };
47323     } catch (std::exception& e) {
47324       {
47325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47326       };
47327     } catch (...) {
47328       {
47329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47330       };
47331     }
47332   }
47333 }
47334
47335
47336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47337   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47338   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47339
47340   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47341   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47342   {
47343     try {
47344       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47345     } catch (std::out_of_range& e) {
47346       {
47347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47348       };
47349     } catch (std::exception& e) {
47350       {
47351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47352       };
47353     } catch (...) {
47354       {
47355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47356       };
47357     }
47358   }
47359 }
47360
47361
47362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47363   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47364   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47365
47366   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47367   arg2 = (Dali::RefObject *)jarg2;
47368   {
47369     try {
47370       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47371     } catch (std::out_of_range& e) {
47372       {
47373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47374       };
47375     } catch (std::exception& e) {
47376       {
47377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47378       };
47379     } catch (...) {
47380       {
47381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47382       };
47383     }
47384   }
47385 }
47386
47387
47388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47389   void * jresult ;
47390   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47391
47392   {
47393     try {
47394       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47395     } catch (std::out_of_range& e) {
47396       {
47397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47398       };
47399     } catch (std::exception& e) {
47400       {
47401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47402       };
47403     } catch (...) {
47404       {
47405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47406       };
47407     }
47408   }
47409   jresult = (void *)result;
47410   return jresult;
47411 }
47412
47413
47414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47415   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47416
47417   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47418   {
47419     try {
47420       delete arg1;
47421     } catch (std::out_of_range& e) {
47422       {
47423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47424       };
47425     } catch (std::exception& e) {
47426       {
47427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47428       };
47429     } catch (...) {
47430       {
47431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47432       };
47433     }
47434   }
47435 }
47436
47437
47438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47439   unsigned int jresult ;
47440   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47441   bool result;
47442
47443   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47444   {
47445     try {
47446       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47447     } catch (std::out_of_range& e) {
47448       {
47449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47450       };
47451     } catch (std::exception& e) {
47452       {
47453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47454       };
47455     } catch (...) {
47456       {
47457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47458       };
47459     }
47460   }
47461   jresult = result;
47462   return jresult;
47463 }
47464
47465
47466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47467   unsigned long jresult ;
47468   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47469   std::size_t result;
47470
47471   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47472   {
47473     try {
47474       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47475     } catch (std::out_of_range& e) {
47476       {
47477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47478       };
47479     } catch (std::exception& e) {
47480       {
47481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47482       };
47483     } catch (...) {
47484       {
47485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47486       };
47487     }
47488   }
47489   jresult = (unsigned long)result;
47490   return jresult;
47491 }
47492
47493
47494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47495   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47496   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47497
47498   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47499   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47500   {
47501     try {
47502       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47503     } catch (std::out_of_range& e) {
47504       {
47505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47506       };
47507     } catch (std::exception& e) {
47508       {
47509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47510       };
47511     } catch (...) {
47512       {
47513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47514       };
47515     }
47516   }
47517 }
47518
47519
47520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47521   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47522   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47523
47524   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47525   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47526   {
47527     try {
47528       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47529     } catch (std::out_of_range& e) {
47530       {
47531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47532       };
47533     } catch (std::exception& e) {
47534       {
47535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47536       };
47537     } catch (...) {
47538       {
47539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47540       };
47541     }
47542   }
47543 }
47544
47545
47546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47547   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47548   Dali::PropertyNotification *arg2 = 0 ;
47549
47550   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47551   arg2 = (Dali::PropertyNotification *)jarg2;
47552   if (!arg2) {
47553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47554     return ;
47555   }
47556   {
47557     try {
47558       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47559     } catch (std::out_of_range& e) {
47560       {
47561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47562       };
47563     } catch (std::exception& e) {
47564       {
47565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47566       };
47567     } catch (...) {
47568       {
47569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47570       };
47571     }
47572   }
47573 }
47574
47575
47576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47577   void * jresult ;
47578   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47579
47580   {
47581     try {
47582       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47603   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47604
47605   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47606   {
47607     try {
47608       delete arg1;
47609     } catch (std::out_of_range& e) {
47610       {
47611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47612       };
47613     } catch (std::exception& e) {
47614       {
47615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47616       };
47617     } catch (...) {
47618       {
47619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47620       };
47621     }
47622   }
47623 }
47624
47625
47626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47627   unsigned int jresult ;
47628   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47629   bool result;
47630
47631   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47632   {
47633     try {
47634       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47635     } catch (std::out_of_range& e) {
47636       {
47637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (std::exception& e) {
47640       {
47641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47642       };
47643     } catch (...) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47646       };
47647     }
47648   }
47649   jresult = result;
47650   return jresult;
47651 }
47652
47653
47654 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47655   unsigned long jresult ;
47656   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47657   std::size_t result;
47658
47659   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47660   {
47661     try {
47662       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47663     } catch (std::out_of_range& e) {
47664       {
47665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47666       };
47667     } catch (std::exception& e) {
47668       {
47669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47670       };
47671     } catch (...) {
47672       {
47673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47674       };
47675     }
47676   }
47677   jresult = (unsigned long)result;
47678   return jresult;
47679 }
47680
47681
47682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47683   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47684   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47685
47686   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47687   arg2 = (void (*)(Dali::Image))jarg2;
47688   {
47689     try {
47690       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47691     } catch (std::out_of_range& e) {
47692       {
47693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47694       };
47695     } catch (std::exception& e) {
47696       {
47697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47698       };
47699     } catch (...) {
47700       {
47701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47702       };
47703     }
47704   }
47705 }
47706
47707
47708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47709   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47710   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47711
47712   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47713   arg2 = (void (*)(Dali::Image))jarg2;
47714   {
47715     try {
47716       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47717     } catch (std::out_of_range& e) {
47718       {
47719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47720       };
47721     } catch (std::exception& e) {
47722       {
47723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47724       };
47725     } catch (...) {
47726       {
47727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47728       };
47729     }
47730   }
47731 }
47732
47733
47734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47735   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47736   Dali::Image arg2 ;
47737   Dali::Image *argp2 ;
47738
47739   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47740   argp2 = (Dali::Image *)jarg2;
47741   if (!argp2) {
47742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47743     return ;
47744   }
47745   arg2 = *argp2;
47746   {
47747     try {
47748       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47749     } catch (std::out_of_range& e) {
47750       {
47751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47752       };
47753     } catch (std::exception& e) {
47754       {
47755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47756       };
47757     } catch (...) {
47758       {
47759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47760       };
47761     }
47762   }
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47767   void * jresult ;
47768   Dali::Signal< void (Dali::Image) > *result = 0 ;
47769
47770   {
47771     try {
47772       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47773     } catch (std::out_of_range& e) {
47774       {
47775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (std::exception& e) {
47778       {
47779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (...) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47784       };
47785     }
47786   }
47787   jresult = (void *)result;
47788   return jresult;
47789 }
47790
47791
47792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47793   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47794
47795   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47796   {
47797     try {
47798       delete arg1;
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47806       };
47807     } catch (...) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47810       };
47811     }
47812   }
47813 }
47814
47815
47816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47817   void * jresult ;
47818   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47819
47820   {
47821     try {
47822       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47823     } catch (std::out_of_range& e) {
47824       {
47825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47826       };
47827     } catch (std::exception& e) {
47828       {
47829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47830       };
47831     } catch (...) {
47832       {
47833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47834       };
47835     }
47836   }
47837   jresult = (void *)result;
47838   return jresult;
47839 }
47840
47841
47842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47843   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47844
47845   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47846   {
47847     try {
47848       delete arg1;
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47856       };
47857     } catch (...) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47860       };
47861     }
47862   }
47863 }
47864
47865
47866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47867   unsigned int jresult ;
47868   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47869   bool result;
47870
47871   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47872   {
47873     try {
47874       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);
47875     } catch (std::out_of_range& e) {
47876       {
47877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47878       };
47879     } catch (std::exception& e) {
47880       {
47881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47886       };
47887     }
47888   }
47889   jresult = result;
47890   return jresult;
47891 }
47892
47893
47894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47895   unsigned long jresult ;
47896   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47897   std::size_t result;
47898
47899   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47900   {
47901     try {
47902       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);
47903     } catch (std::out_of_range& e) {
47904       {
47905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (std::exception& e) {
47908       {
47909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47910       };
47911     } catch (...) {
47912       {
47913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47914       };
47915     }
47916   }
47917   jresult = (unsigned long)result;
47918   return jresult;
47919 }
47920
47921
47922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47923   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47924   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47925
47926   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47927   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47928   {
47929     try {
47930       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47931     } catch (std::out_of_range& e) {
47932       {
47933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47934       };
47935     } catch (std::exception& e) {
47936       {
47937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47938       };
47939     } catch (...) {
47940       {
47941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47942       };
47943     }
47944   }
47945 }
47946
47947
47948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47949   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47950   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47951
47952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47953   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47954   {
47955     try {
47956       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
47957     } catch (std::out_of_range& e) {
47958       {
47959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47960       };
47961     } catch (std::exception& e) {
47962       {
47963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47964       };
47965     } catch (...) {
47966       {
47967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47968       };
47969     }
47970   }
47971 }
47972
47973
47974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
47975   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47976   Dali::Actor arg2 ;
47977   Dali::LongPressGesture *arg3 = 0 ;
47978   Dali::Actor *argp2 ;
47979
47980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47981   argp2 = (Dali::Actor *)jarg2;
47982   if (!argp2) {
47983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47984     return ;
47985   }
47986   arg2 = *argp2;
47987   arg3 = (Dali::LongPressGesture *)jarg3;
47988   if (!arg3) {
47989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
47990     return ;
47991   }
47992   {
47993     try {
47994       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
47995     } catch (std::out_of_range& e) {
47996       {
47997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (std::exception& e) {
48000       {
48001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48002       };
48003     } catch (...) {
48004       {
48005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48006       };
48007     }
48008   }
48009 }
48010
48011
48012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
48013   void * jresult ;
48014   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48015
48016   {
48017     try {
48018       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48030       };
48031     }
48032   }
48033   jresult = (void *)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48039   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48040
48041   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48042   {
48043     try {
48044       delete arg1;
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48056       };
48057     }
48058   }
48059 }
48060
48061
48062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48063   unsigned int jresult ;
48064   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48065   bool result;
48066
48067   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48068   {
48069     try {
48070       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);
48071     } catch (std::out_of_range& e) {
48072       {
48073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48074       };
48075     } catch (std::exception& e) {
48076       {
48077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48078       };
48079     } catch (...) {
48080       {
48081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48082       };
48083     }
48084   }
48085   jresult = result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48091   unsigned long jresult ;
48092   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48093   std::size_t result;
48094
48095   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48096   {
48097     try {
48098       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);
48099     } catch (std::out_of_range& e) {
48100       {
48101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48102       };
48103     } catch (std::exception& e) {
48104       {
48105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48106       };
48107     } catch (...) {
48108       {
48109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48110       };
48111     }
48112   }
48113   jresult = (unsigned long)result;
48114   return jresult;
48115 }
48116
48117
48118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48119   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48120   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48121
48122   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48123   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48124   {
48125     try {
48126       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48127     } catch (std::out_of_range& e) {
48128       {
48129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48130       };
48131     } catch (std::exception& e) {
48132       {
48133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48134       };
48135     } catch (...) {
48136       {
48137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48138       };
48139     }
48140   }
48141 }
48142
48143
48144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48145   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48146   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48147
48148   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48149   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48150   {
48151     try {
48152       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48153     } catch (std::out_of_range& e) {
48154       {
48155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48156       };
48157     } catch (std::exception& e) {
48158       {
48159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48160       };
48161     } catch (...) {
48162       {
48163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48164       };
48165     }
48166   }
48167 }
48168
48169
48170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48171   unsigned int jresult ;
48172   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48173   Dali::Actor arg2 ;
48174   Dali::TouchData *arg3 = 0 ;
48175   Dali::Actor *argp2 ;
48176   bool result;
48177
48178   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48179   argp2 = (Dali::Actor *)jarg2;
48180   if (!argp2) {
48181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48182     return 0;
48183   }
48184   arg2 = *argp2;
48185   arg3 = (Dali::TouchData *)jarg3;
48186   if (!arg3) {
48187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48188     return 0;
48189   }
48190   {
48191     try {
48192       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48193     } catch (std::out_of_range& e) {
48194       {
48195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48196       };
48197     } catch (std::exception& e) {
48198       {
48199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48200       };
48201     } catch (...) {
48202       {
48203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48204       };
48205     }
48206   }
48207   jresult = result;
48208   return jresult;
48209 }
48210
48211
48212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48213   void * jresult ;
48214   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48215
48216   {
48217     try {
48218       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48219     } catch (std::out_of_range& e) {
48220       {
48221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48222       };
48223     } catch (std::exception& e) {
48224       {
48225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48226       };
48227     } catch (...) {
48228       {
48229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48230       };
48231     }
48232   }
48233   jresult = (void *)result;
48234   return jresult;
48235 }
48236
48237
48238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48239   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48240
48241   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48242   {
48243     try {
48244       delete arg1;
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (...) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48256       };
48257     }
48258   }
48259 }
48260
48261
48262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48263   unsigned int jresult ;
48264   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48265   bool result;
48266
48267   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48268   {
48269     try {
48270       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);
48271     } catch (std::out_of_range& e) {
48272       {
48273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48274       };
48275     } catch (std::exception& e) {
48276       {
48277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (...) {
48280       {
48281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48282       };
48283     }
48284   }
48285   jresult = result;
48286   return jresult;
48287 }
48288
48289
48290 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48291   unsigned long jresult ;
48292   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48293   std::size_t result;
48294
48295   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48296   {
48297     try {
48298       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);
48299     } catch (std::out_of_range& e) {
48300       {
48301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48302       };
48303     } catch (std::exception& e) {
48304       {
48305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48306       };
48307     } catch (...) {
48308       {
48309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48310       };
48311     }
48312   }
48313   jresult = (unsigned long)result;
48314   return jresult;
48315 }
48316
48317
48318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48319   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48320   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48321
48322   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48323   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48324   {
48325     try {
48326       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48334       };
48335     } catch (...) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48338       };
48339     }
48340   }
48341 }
48342
48343
48344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48345   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48346   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48347
48348   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48349   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48350   {
48351     try {
48352       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48353     } catch (std::out_of_range& e) {
48354       {
48355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48356       };
48357     } catch (std::exception& e) {
48358       {
48359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48360       };
48361     } catch (...) {
48362       {
48363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48364       };
48365     }
48366   }
48367 }
48368
48369
48370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48371   unsigned int jresult ;
48372   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48373   Dali::Actor arg2 ;
48374   Dali::HoverEvent *arg3 = 0 ;
48375   Dali::Actor *argp2 ;
48376   bool result;
48377
48378   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48379   argp2 = (Dali::Actor *)jarg2;
48380   if (!argp2) {
48381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48382     return 0;
48383   }
48384   arg2 = *argp2;
48385   arg3 = (Dali::HoverEvent *)jarg3;
48386   if (!arg3) {
48387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48388     return 0;
48389   }
48390   {
48391     try {
48392       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48393     } catch (std::out_of_range& e) {
48394       {
48395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48396       };
48397     } catch (std::exception& e) {
48398       {
48399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48400       };
48401     } catch (...) {
48402       {
48403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48404       };
48405     }
48406   }
48407   jresult = result;
48408   return jresult;
48409 }
48410
48411
48412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48413   void * jresult ;
48414   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48415
48416   {
48417     try {
48418       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48419     } catch (std::out_of_range& e) {
48420       {
48421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48422       };
48423     } catch (std::exception& e) {
48424       {
48425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48430       };
48431     }
48432   }
48433   jresult = (void *)result;
48434   return jresult;
48435 }
48436
48437
48438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48439   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48440
48441   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48442   {
48443     try {
48444       delete arg1;
48445     } catch (std::out_of_range& e) {
48446       {
48447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48448       };
48449     } catch (std::exception& e) {
48450       {
48451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48452       };
48453     } catch (...) {
48454       {
48455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48456       };
48457     }
48458   }
48459 }
48460
48461
48462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48463   unsigned int jresult ;
48464   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48465   bool result;
48466
48467   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48468   {
48469     try {
48470       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);
48471     } catch (std::out_of_range& e) {
48472       {
48473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48474       };
48475     } catch (std::exception& e) {
48476       {
48477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48478       };
48479     } catch (...) {
48480       {
48481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48482       };
48483     }
48484   }
48485   jresult = result;
48486   return jresult;
48487 }
48488
48489
48490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48491   unsigned long jresult ;
48492   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48493   std::size_t result;
48494
48495   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48496   {
48497     try {
48498       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);
48499     } catch (std::out_of_range& e) {
48500       {
48501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48502       };
48503     } catch (std::exception& e) {
48504       {
48505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48506       };
48507     } catch (...) {
48508       {
48509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48510       };
48511     }
48512   }
48513   jresult = (unsigned long)result;
48514   return jresult;
48515 }
48516
48517
48518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48519   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48520   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48521
48522   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48523   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48524   {
48525     try {
48526       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48527     } catch (std::out_of_range& e) {
48528       {
48529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48530       };
48531     } catch (std::exception& e) {
48532       {
48533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48534       };
48535     } catch (...) {
48536       {
48537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48538       };
48539     }
48540   }
48541 }
48542
48543
48544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48545   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48546   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48547
48548   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48549   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48550   {
48551     try {
48552       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48553     } catch (std::out_of_range& e) {
48554       {
48555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48556       };
48557     } catch (std::exception& e) {
48558       {
48559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48560       };
48561     } catch (...) {
48562       {
48563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48564       };
48565     }
48566   }
48567 }
48568
48569
48570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48571   unsigned int jresult ;
48572   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48573   Dali::Actor arg2 ;
48574   Dali::WheelEvent *arg3 = 0 ;
48575   Dali::Actor *argp2 ;
48576   bool result;
48577
48578   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48579   argp2 = (Dali::Actor *)jarg2;
48580   if (!argp2) {
48581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48582     return 0;
48583   }
48584   arg2 = *argp2;
48585   arg3 = (Dali::WheelEvent *)jarg3;
48586   if (!arg3) {
48587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48588     return 0;
48589   }
48590   {
48591     try {
48592       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48593     } catch (std::out_of_range& e) {
48594       {
48595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48596       };
48597     } catch (std::exception& e) {
48598       {
48599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48600       };
48601     } catch (...) {
48602       {
48603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48604       };
48605     }
48606   }
48607   jresult = result;
48608   return jresult;
48609 }
48610
48611
48612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48613   void * jresult ;
48614   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48615
48616   {
48617     try {
48618       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48619     } catch (std::out_of_range& e) {
48620       {
48621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (std::exception& e) {
48624       {
48625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48626       };
48627     } catch (...) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48630       };
48631     }
48632   }
48633   jresult = (void *)result;
48634   return jresult;
48635 }
48636
48637
48638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48639   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48640
48641   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48642   {
48643     try {
48644       delete arg1;
48645     } catch (std::out_of_range& e) {
48646       {
48647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48648       };
48649     } catch (std::exception& e) {
48650       {
48651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48652       };
48653     } catch (...) {
48654       {
48655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48656       };
48657     }
48658   }
48659 }
48660
48661
48662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48663   unsigned int jresult ;
48664   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48665   bool result;
48666
48667   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48668   {
48669     try {
48670       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48678       };
48679     } catch (...) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48682       };
48683     }
48684   }
48685   jresult = result;
48686   return jresult;
48687 }
48688
48689
48690 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48691   unsigned long jresult ;
48692   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48693   std::size_t result;
48694
48695   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48696   {
48697     try {
48698       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48699     } catch (std::out_of_range& e) {
48700       {
48701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48702       };
48703     } catch (std::exception& e) {
48704       {
48705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48706       };
48707     } catch (...) {
48708       {
48709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48710       };
48711     }
48712   }
48713   jresult = (unsigned long)result;
48714   return jresult;
48715 }
48716
48717
48718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48719   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48720   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48721
48722   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48723   arg2 = (void (*)(Dali::Actor))jarg2;
48724   {
48725     try {
48726       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48727     } catch (std::out_of_range& e) {
48728       {
48729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (std::exception& e) {
48732       {
48733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48734       };
48735     } catch (...) {
48736       {
48737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48738       };
48739     }
48740   }
48741 }
48742
48743
48744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48745   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48746   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48747
48748   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48749   arg2 = (void (*)(Dali::Actor))jarg2;
48750   {
48751     try {
48752       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48764       };
48765     }
48766   }
48767 }
48768
48769
48770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48771   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48772   Dali::Actor arg2 ;
48773   Dali::Actor *argp2 ;
48774
48775   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48776   argp2 = (Dali::Actor *)jarg2;
48777   if (!argp2) {
48778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48779     return ;
48780   }
48781   arg2 = *argp2;
48782   {
48783     try {
48784       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48785     } catch (std::out_of_range& e) {
48786       {
48787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48788       };
48789     } catch (std::exception& e) {
48790       {
48791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48792       };
48793     } catch (...) {
48794       {
48795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48796       };
48797     }
48798   }
48799 }
48800
48801
48802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48803   void * jresult ;
48804   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48805
48806   {
48807     try {
48808       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48809     } catch (std::out_of_range& e) {
48810       {
48811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48812       };
48813     } catch (std::exception& e) {
48814       {
48815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48816       };
48817     } catch (...) {
48818       {
48819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48820       };
48821     }
48822   }
48823   jresult = (void *)result;
48824   return jresult;
48825 }
48826
48827
48828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48829   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48830
48831   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48832   {
48833     try {
48834       delete arg1;
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48842       };
48843     } catch (...) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48846       };
48847     }
48848   }
48849 }
48850
48851
48852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48853   unsigned int jresult ;
48854   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48855   bool result;
48856
48857   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48858   {
48859     try {
48860       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48861     } catch (std::out_of_range& e) {
48862       {
48863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48864       };
48865     } catch (std::exception& e) {
48866       {
48867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48868       };
48869     } catch (...) {
48870       {
48871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48872       };
48873     }
48874   }
48875   jresult = result;
48876   return jresult;
48877 }
48878
48879
48880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48881   unsigned long jresult ;
48882   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48883   std::size_t result;
48884
48885   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48886   {
48887     try {
48888       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48889     } catch (std::out_of_range& e) {
48890       {
48891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48892       };
48893     } catch (std::exception& e) {
48894       {
48895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48896       };
48897     } catch (...) {
48898       {
48899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48900       };
48901     }
48902   }
48903   jresult = (unsigned long)result;
48904   return jresult;
48905 }
48906
48907
48908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48909   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48910   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48911
48912   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48913   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48914   {
48915     try {
48916       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48917     } catch (std::out_of_range& e) {
48918       {
48919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48920       };
48921     } catch (std::exception& e) {
48922       {
48923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48924       };
48925     } catch (...) {
48926       {
48927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48928       };
48929     }
48930   }
48931 }
48932
48933
48934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48935   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48936   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48937
48938   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48939   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48940   {
48941     try {
48942       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48943     } catch (std::out_of_range& e) {
48944       {
48945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48946       };
48947     } catch (std::exception& e) {
48948       {
48949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48950       };
48951     } catch (...) {
48952       {
48953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48954       };
48955     }
48956   }
48957 }
48958
48959
48960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
48961   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48962   Dali::KeyEvent *arg2 = 0 ;
48963
48964   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48965   arg2 = (Dali::KeyEvent *)jarg2;
48966   if (!arg2) {
48967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
48968     return ;
48969   }
48970   {
48971     try {
48972       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
48973     } catch (std::out_of_range& e) {
48974       {
48975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48976       };
48977     } catch (std::exception& e) {
48978       {
48979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48980       };
48981     } catch (...) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48984       };
48985     }
48986   }
48987 }
48988
48989
48990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
48991   void * jresult ;
48992   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
48993
48994   {
48995     try {
48996       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49004       };
49005     } catch (...) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49008       };
49009     }
49010   }
49011   jresult = (void *)result;
49012   return jresult;
49013 }
49014
49015
49016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49017   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49018
49019   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49020   {
49021     try {
49022       delete arg1;
49023     } catch (std::out_of_range& e) {
49024       {
49025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49026       };
49027     } catch (std::exception& e) {
49028       {
49029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49030       };
49031     } catch (...) {
49032       {
49033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49034       };
49035     }
49036   }
49037 }
49038
49039
49040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49041   unsigned int jresult ;
49042   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49043   bool result;
49044
49045   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49046   {
49047     try {
49048       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49049     } catch (std::out_of_range& e) {
49050       {
49051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49052       };
49053     } catch (std::exception& e) {
49054       {
49055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49056       };
49057     } catch (...) {
49058       {
49059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49060       };
49061     }
49062   }
49063   jresult = result;
49064   return jresult;
49065 }
49066
49067
49068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49069   unsigned long jresult ;
49070   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49071   std::size_t result;
49072
49073   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49074   {
49075     try {
49076       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49077     } catch (std::out_of_range& e) {
49078       {
49079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49080       };
49081     } catch (std::exception& e) {
49082       {
49083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49088       };
49089     }
49090   }
49091   jresult = (unsigned long)result;
49092   return jresult;
49093 }
49094
49095
49096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49097   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49098   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49099
49100   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49101   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49102   {
49103     try {
49104       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49105     } catch (std::out_of_range& e) {
49106       {
49107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49108       };
49109     } catch (std::exception& e) {
49110       {
49111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49112       };
49113     } catch (...) {
49114       {
49115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49116       };
49117     }
49118   }
49119 }
49120
49121
49122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49123   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49124   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49125
49126   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49127   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49128   {
49129     try {
49130       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49131     } catch (std::out_of_range& e) {
49132       {
49133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49134       };
49135     } catch (std::exception& e) {
49136       {
49137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49138       };
49139     } catch (...) {
49140       {
49141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49142       };
49143     }
49144   }
49145 }
49146
49147
49148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49149   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49150   Dali::TouchData *arg2 = 0 ;
49151
49152   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49153   arg2 = (Dali::TouchData *)jarg2;
49154   if (!arg2) {
49155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49156     return ;
49157   }
49158   {
49159     try {
49160       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49161     } catch (std::out_of_range& e) {
49162       {
49163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49164       };
49165     } catch (std::exception& e) {
49166       {
49167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49168       };
49169     } catch (...) {
49170       {
49171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49172       };
49173     }
49174   }
49175 }
49176
49177
49178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49179   void * jresult ;
49180   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49181
49182   {
49183     try {
49184       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49185     } catch (std::out_of_range& e) {
49186       {
49187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49188       };
49189     } catch (std::exception& e) {
49190       {
49191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49192       };
49193     } catch (...) {
49194       {
49195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49196       };
49197     }
49198   }
49199   jresult = (void *)result;
49200   return jresult;
49201 }
49202
49203
49204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49205   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49206
49207   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49208   {
49209     try {
49210       delete arg1;
49211     } catch (std::out_of_range& e) {
49212       {
49213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49214       };
49215     } catch (std::exception& e) {
49216       {
49217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49218       };
49219     } catch (...) {
49220       {
49221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49222       };
49223     }
49224   }
49225 }
49226
49227
49228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49229   unsigned int jresult ;
49230   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49231   bool result;
49232
49233   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49234   {
49235     try {
49236       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49237     } catch (std::out_of_range& e) {
49238       {
49239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49240       };
49241     } catch (std::exception& e) {
49242       {
49243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (...) {
49246       {
49247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49248       };
49249     }
49250   }
49251   jresult = result;
49252   return jresult;
49253 }
49254
49255
49256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49257   unsigned long jresult ;
49258   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49259   std::size_t result;
49260
49261   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49262   {
49263     try {
49264       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49265     } catch (std::out_of_range& e) {
49266       {
49267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49268       };
49269     } catch (std::exception& e) {
49270       {
49271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49272       };
49273     } catch (...) {
49274       {
49275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49276       };
49277     }
49278   }
49279   jresult = (unsigned long)result;
49280   return jresult;
49281 }
49282
49283
49284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49285   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49286   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49287
49288   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49289   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49290   {
49291     try {
49292       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49293     } catch (std::out_of_range& e) {
49294       {
49295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49296       };
49297     } catch (std::exception& e) {
49298       {
49299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49300       };
49301     } catch (...) {
49302       {
49303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49304       };
49305     }
49306   }
49307 }
49308
49309
49310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49311   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49312   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49313
49314   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49315   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49316   {
49317     try {
49318       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49319     } catch (std::out_of_range& e) {
49320       {
49321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49322       };
49323     } catch (std::exception& e) {
49324       {
49325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49326       };
49327     } catch (...) {
49328       {
49329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49330       };
49331     }
49332   }
49333 }
49334
49335
49336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49337   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49338   Dali::WheelEvent *arg2 = 0 ;
49339
49340   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49341   arg2 = (Dali::WheelEvent *)jarg2;
49342   if (!arg2) {
49343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49344     return ;
49345   }
49346   {
49347     try {
49348       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49349     } catch (std::out_of_range& e) {
49350       {
49351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49352       };
49353     } catch (std::exception& e) {
49354       {
49355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49356       };
49357     } catch (...) {
49358       {
49359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49360       };
49361     }
49362   }
49363 }
49364
49365
49366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49367   void * jresult ;
49368   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49369
49370   {
49371     try {
49372       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49373     } catch (std::out_of_range& e) {
49374       {
49375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49376       };
49377     } catch (std::exception& e) {
49378       {
49379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49380       };
49381     } catch (...) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49384       };
49385     }
49386   }
49387   jresult = (void *)result;
49388   return jresult;
49389 }
49390
49391
49392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49393   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49394
49395   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49396   {
49397     try {
49398       delete arg1;
49399     } catch (std::out_of_range& e) {
49400       {
49401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49402       };
49403     } catch (std::exception& e) {
49404       {
49405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49406       };
49407     } catch (...) {
49408       {
49409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49410       };
49411     }
49412   }
49413 }
49414
49415
49416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49417   void * jresult ;
49418   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49419
49420   {
49421     try {
49422       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49423     } catch (std::out_of_range& e) {
49424       {
49425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49426       };
49427     } catch (std::exception& e) {
49428       {
49429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49430       };
49431     } catch (...) {
49432       {
49433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49434       };
49435     }
49436   }
49437   jresult = (void *)result;
49438   return jresult;
49439 }
49440
49441
49442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49443   void * jresult ;
49444   Dali::Radian arg1 ;
49445   Dali::Radian arg2 ;
49446   Dali::Radian *argp1 ;
49447   Dali::Radian *argp2 ;
49448   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49449
49450   argp1 = (Dali::Radian *)jarg1;
49451   if (!argp1) {
49452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49453     return 0;
49454   }
49455   arg1 = *argp1;
49456   argp2 = (Dali::Radian *)jarg2;
49457   if (!argp2) {
49458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49459     return 0;
49460   }
49461   arg2 = *argp2;
49462   {
49463     try {
49464       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49465     } catch (std::out_of_range& e) {
49466       {
49467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49468       };
49469     } catch (std::exception& e) {
49470       {
49471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (...) {
49474       {
49475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49476       };
49477     }
49478   }
49479   jresult = (void *)result;
49480   return jresult;
49481 }
49482
49483
49484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49485   void * jresult ;
49486   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49487   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49488
49489   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49490   if (!arg1) {
49491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49492     return 0;
49493   }
49494   {
49495     try {
49496       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49497     } catch (std::out_of_range& e) {
49498       {
49499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (std::exception& e) {
49502       {
49503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (...) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49508       };
49509     }
49510   }
49511   jresult = (void *)result;
49512   return jresult;
49513 }
49514
49515
49516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49517   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49518   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49519
49520   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49521   arg2 = (Dali::Radian *)jarg2;
49522   if (arg1) (arg1)->first = *arg2;
49523 }
49524
49525
49526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49527   void * jresult ;
49528   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49529   Dali::Radian *result = 0 ;
49530
49531   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49532   result = (Dali::Radian *)& ((arg1)->first);
49533   jresult = (void *)result;
49534   return jresult;
49535 }
49536
49537
49538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49539   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49540   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49541
49542   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49543   arg2 = (Dali::Radian *)jarg2;
49544   if (arg1) (arg1)->second = *arg2;
49545 }
49546
49547
49548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49549   void * jresult ;
49550   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49551   Dali::Radian *result = 0 ;
49552
49553   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49554   result = (Dali::Radian *)& ((arg1)->second);
49555   jresult = (void *)result;
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49561   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49562
49563   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49564   {
49565     try {
49566       delete arg1;
49567     } catch (std::out_of_range& e) {
49568       {
49569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49570       };
49571     } catch (std::exception& e) {
49572       {
49573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49574       };
49575     } catch (...) {
49576       {
49577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49578       };
49579     }
49580   }
49581 }
49582
49583
49584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49585   unsigned int jresult ;
49586   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49587   bool result;
49588
49589   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49590   {
49591     try {
49592       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);
49593     } catch (std::out_of_range& e) {
49594       {
49595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49596       };
49597     } catch (std::exception& e) {
49598       {
49599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49604       };
49605     }
49606   }
49607   jresult = result;
49608   return jresult;
49609 }
49610
49611
49612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49613   unsigned long jresult ;
49614   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49615   std::size_t result;
49616
49617   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49618   {
49619     try {
49620       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);
49621     } catch (std::out_of_range& e) {
49622       {
49623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49624       };
49625     } catch (std::exception& e) {
49626       {
49627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49628       };
49629     } catch (...) {
49630       {
49631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49632       };
49633     }
49634   }
49635   jresult = (unsigned long)result;
49636   return jresult;
49637 }
49638
49639
49640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49641   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49642   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49643
49644   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49645   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49646   {
49647     try {
49648       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49649     } catch (std::out_of_range& e) {
49650       {
49651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49652       };
49653     } catch (std::exception& e) {
49654       {
49655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49656       };
49657     } catch (...) {
49658       {
49659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49660       };
49661     }
49662   }
49663 }
49664
49665
49666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49667   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49668   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49669
49670   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49671   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49672   {
49673     try {
49674       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49675     } catch (std::out_of_range& e) {
49676       {
49677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49678       };
49679     } catch (std::exception& e) {
49680       {
49681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49682       };
49683     } catch (...) {
49684       {
49685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49686       };
49687     }
49688   }
49689 }
49690
49691
49692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49693   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49694   Dali::Actor arg2 ;
49695   Dali::PanGesture *arg3 = 0 ;
49696   Dali::Actor *argp2 ;
49697
49698   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49699   argp2 = (Dali::Actor *)jarg2;
49700   if (!argp2) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49702     return ;
49703   }
49704   arg2 = *argp2;
49705   arg3 = (Dali::PanGesture *)jarg3;
49706   if (!arg3) {
49707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49708     return ;
49709   }
49710   {
49711     try {
49712       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49713     } catch (std::out_of_range& e) {
49714       {
49715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (std::exception& e) {
49718       {
49719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (...) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49724       };
49725     }
49726   }
49727 }
49728
49729
49730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49731   void * jresult ;
49732   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49733
49734   {
49735     try {
49736       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49737     } catch (std::out_of_range& e) {
49738       {
49739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49740       };
49741     } catch (std::exception& e) {
49742       {
49743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49744       };
49745     } catch (...) {
49746       {
49747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49748       };
49749     }
49750   }
49751   jresult = (void *)result;
49752   return jresult;
49753 }
49754
49755
49756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49757   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49758
49759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49760   {
49761     try {
49762       delete arg1;
49763     } catch (std::out_of_range& e) {
49764       {
49765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49766       };
49767     } catch (std::exception& e) {
49768       {
49769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49770       };
49771     } catch (...) {
49772       {
49773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49774       };
49775     }
49776   }
49777 }
49778
49779
49780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49781   unsigned int jresult ;
49782   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49783   bool result;
49784
49785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49786   {
49787     try {
49788       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);
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49796       };
49797     } catch (...) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49800       };
49801     }
49802   }
49803   jresult = result;
49804   return jresult;
49805 }
49806
49807
49808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49809   unsigned long jresult ;
49810   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49811   std::size_t result;
49812
49813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49814   {
49815     try {
49816       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);
49817     } catch (std::out_of_range& e) {
49818       {
49819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49820       };
49821     } catch (std::exception& e) {
49822       {
49823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49824       };
49825     } catch (...) {
49826       {
49827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49828       };
49829     }
49830   }
49831   jresult = (unsigned long)result;
49832   return jresult;
49833 }
49834
49835
49836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49837   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49838   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49839
49840   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49841   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49842   {
49843     try {
49844       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49845     } catch (std::out_of_range& e) {
49846       {
49847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49848       };
49849     } catch (std::exception& e) {
49850       {
49851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49852       };
49853     } catch (...) {
49854       {
49855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49856       };
49857     }
49858   }
49859 }
49860
49861
49862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49863   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49864   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49865
49866   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49867   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49868   {
49869     try {
49870       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49871     } catch (std::out_of_range& e) {
49872       {
49873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (std::exception& e) {
49876       {
49877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49878       };
49879     } catch (...) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49882       };
49883     }
49884   }
49885 }
49886
49887
49888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49889   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49890   Dali::Actor arg2 ;
49891   Dali::PinchGesture *arg3 = 0 ;
49892   Dali::Actor *argp2 ;
49893
49894   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49895   argp2 = (Dali::Actor *)jarg2;
49896   if (!argp2) {
49897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49898     return ;
49899   }
49900   arg2 = *argp2;
49901   arg3 = (Dali::PinchGesture *)jarg3;
49902   if (!arg3) {
49903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49904     return ;
49905   }
49906   {
49907     try {
49908       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49909     } catch (std::out_of_range& e) {
49910       {
49911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49912       };
49913     } catch (std::exception& e) {
49914       {
49915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49916       };
49917     } catch (...) {
49918       {
49919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49920       };
49921     }
49922   }
49923 }
49924
49925
49926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49927   void * jresult ;
49928   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49929
49930   {
49931     try {
49932       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49933     } catch (std::out_of_range& e) {
49934       {
49935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49936       };
49937     } catch (std::exception& e) {
49938       {
49939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49940       };
49941     } catch (...) {
49942       {
49943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49944       };
49945     }
49946   }
49947   jresult = (void *)result;
49948   return jresult;
49949 }
49950
49951
49952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49953   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49954
49955   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49956   {
49957     try {
49958       delete arg1;
49959     } catch (std::out_of_range& e) {
49960       {
49961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (std::exception& e) {
49964       {
49965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (...) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49970       };
49971     }
49972   }
49973 }
49974
49975
49976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
49977   unsigned int jresult ;
49978   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
49979   bool result;
49980
49981   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
49982   {
49983     try {
49984       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);
49985     } catch (std::out_of_range& e) {
49986       {
49987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49988       };
49989     } catch (std::exception& e) {
49990       {
49991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49992       };
49993     } catch (...) {
49994       {
49995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49996       };
49997     }
49998   }
49999   jresult = result;
50000   return jresult;
50001 }
50002
50003
50004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50005   unsigned long jresult ;
50006   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50007   std::size_t result;
50008
50009   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50010   {
50011     try {
50012       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);
50013     } catch (std::out_of_range& e) {
50014       {
50015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50016       };
50017     } catch (std::exception& e) {
50018       {
50019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50020       };
50021     } catch (...) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50024       };
50025     }
50026   }
50027   jresult = (unsigned long)result;
50028   return jresult;
50029 }
50030
50031
50032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50033   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50034   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50035
50036   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50037   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50038   {
50039     try {
50040       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50041     } catch (std::out_of_range& e) {
50042       {
50043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50044       };
50045     } catch (std::exception& e) {
50046       {
50047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50048       };
50049     } catch (...) {
50050       {
50051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50052       };
50053     }
50054   }
50055 }
50056
50057
50058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50059   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50060   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50061
50062   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50063   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50064   {
50065     try {
50066       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50067     } catch (std::out_of_range& e) {
50068       {
50069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50070       };
50071     } catch (std::exception& e) {
50072       {
50073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50074       };
50075     } catch (...) {
50076       {
50077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50078       };
50079     }
50080   }
50081 }
50082
50083
50084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50085   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50086   Dali::Actor arg2 ;
50087   Dali::TapGesture *arg3 = 0 ;
50088   Dali::Actor *argp2 ;
50089
50090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50091   argp2 = (Dali::Actor *)jarg2;
50092   if (!argp2) {
50093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50094     return ;
50095   }
50096   arg2 = *argp2;
50097   arg3 = (Dali::TapGesture *)jarg3;
50098   if (!arg3) {
50099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50100     return ;
50101   }
50102   {
50103     try {
50104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50105     } catch (std::out_of_range& e) {
50106       {
50107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50108       };
50109     } catch (std::exception& e) {
50110       {
50111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50116       };
50117     }
50118   }
50119 }
50120
50121
50122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50123   void * jresult ;
50124   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50125
50126   {
50127     try {
50128       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50129     } catch (std::out_of_range& e) {
50130       {
50131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50132       };
50133     } catch (std::exception& e) {
50134       {
50135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50136       };
50137     } catch (...) {
50138       {
50139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50140       };
50141     }
50142   }
50143   jresult = (void *)result;
50144   return jresult;
50145 }
50146
50147
50148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50149   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50150
50151   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50152   {
50153     try {
50154       delete arg1;
50155     } catch (std::out_of_range& e) {
50156       {
50157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50158       };
50159     } catch (std::exception& e) {
50160       {
50161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50162       };
50163     } catch (...) {
50164       {
50165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50166       };
50167     }
50168   }
50169 }
50170
50171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50172   unsigned int jresult ;
50173   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50174   bool result;
50175
50176   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50177   {
50178     try {
50179       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50180     } catch (std::out_of_range& e) {
50181       {
50182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50183       };
50184     } catch (std::exception& e) {
50185       {
50186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50187       };
50188     } catch (...) {
50189       {
50190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50191       };
50192     }
50193   }
50194   jresult = result;
50195   return jresult;
50196 }
50197
50198
50199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50200   unsigned long jresult ;
50201   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50202   std::size_t result;
50203
50204   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50205   {
50206     try {
50207       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50208     } catch (std::out_of_range& e) {
50209       {
50210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50211       };
50212     } catch (std::exception& e) {
50213       {
50214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50215       };
50216     } catch (...) {
50217       {
50218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50219       };
50220     }
50221   }
50222   jresult = (unsigned long)result;
50223   return jresult;
50224 }
50225
50226
50227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50228   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50229   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50230
50231   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50232   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50233   {
50234     try {
50235       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50236     } catch (std::out_of_range& e) {
50237       {
50238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50239       };
50240     } catch (std::exception& e) {
50241       {
50242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50243       };
50244     } catch (...) {
50245       {
50246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50247       };
50248     }
50249   }
50250 }
50251
50252
50253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50254   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50255   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50256
50257   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50258   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50259   {
50260     try {
50261       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50262     } catch (std::out_of_range& e) {
50263       {
50264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50265       };
50266     } catch (std::exception& e) {
50267       {
50268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50269       };
50270     } catch (...) {
50271       {
50272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50273       };
50274     }
50275   }
50276 }
50277
50278
50279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50280   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50281   Dali::ResourceImage arg2 ;
50282   Dali::ResourceImage *argp2 ;
50283
50284   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50285   argp2 = (Dali::ResourceImage *)jarg2;
50286   if (!argp2) {
50287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50288     return ;
50289   }
50290   arg2 = *argp2;
50291   {
50292     try {
50293       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50294     } catch (std::out_of_range& e) {
50295       {
50296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50297       };
50298     } catch (std::exception& e) {
50299       {
50300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50301       };
50302     } catch (...) {
50303       {
50304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50305       };
50306     }
50307   }
50308 }
50309
50310
50311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50312   void * jresult ;
50313   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50314
50315   {
50316     try {
50317       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50318     } catch (std::out_of_range& e) {
50319       {
50320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50321       };
50322     } catch (std::exception& e) {
50323       {
50324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50325       };
50326     } catch (...) {
50327       {
50328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50329       };
50330     }
50331   }
50332   jresult = (void *)result;
50333   return jresult;
50334 }
50335
50336
50337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50338   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50339
50340   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50341   {
50342     try {
50343       delete arg1;
50344     } catch (std::out_of_range& e) {
50345       {
50346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50347       };
50348     } catch (std::exception& e) {
50349       {
50350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50351       };
50352     } catch (...) {
50353       {
50354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50355       };
50356     }
50357   }
50358 }
50359
50360
50361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50362   unsigned int jresult ;
50363   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50364   bool result;
50365
50366   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50367   {
50368     try {
50369       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);
50370     } catch (std::out_of_range& e) {
50371       {
50372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (std::exception& e) {
50375       {
50376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50377       };
50378     } catch (...) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50381       };
50382     }
50383   }
50384   jresult = result;
50385   return jresult;
50386 }
50387
50388
50389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50390   unsigned long jresult ;
50391   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50392   std::size_t result;
50393
50394   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50395   {
50396     try {
50397       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);
50398     } catch (std::out_of_range& e) {
50399       {
50400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50401       };
50402     } catch (std::exception& e) {
50403       {
50404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50405       };
50406     } catch (...) {
50407       {
50408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50409       };
50410     }
50411   }
50412   jresult = (unsigned long)result;
50413   return jresult;
50414 }
50415
50416
50417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50418   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50419   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50420
50421   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50422   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50423   {
50424     try {
50425       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50426     } catch (std::out_of_range& e) {
50427       {
50428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50429       };
50430     } catch (std::exception& e) {
50431       {
50432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50433       };
50434     } catch (...) {
50435       {
50436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50437       };
50438     }
50439   }
50440 }
50441
50442
50443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50444   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50445   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50446
50447   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50448   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50449   {
50450     try {
50451       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50452     } catch (std::out_of_range& e) {
50453       {
50454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50455       };
50456     } catch (std::exception& e) {
50457       {
50458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50459       };
50460     } catch (...) {
50461       {
50462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50463       };
50464     }
50465   }
50466 }
50467
50468
50469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50470   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50471   Dali::Actor arg2 ;
50472   bool arg3 ;
50473   Dali::DevelActor::VisibilityChange::Type arg4 ;
50474   Dali::Actor *argp2 ;
50475
50476   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50477   argp2 = (Dali::Actor *)jarg2;
50478   if (!argp2) {
50479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50480     return ;
50481   }
50482   arg2 = *argp2;
50483   arg3 = jarg3 ? true : false;
50484   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50485   {
50486     try {
50487       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50488     } catch (std::out_of_range& e) {
50489       {
50490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50491       };
50492     } catch (std::exception& e) {
50493       {
50494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50495       };
50496     } catch (...) {
50497       {
50498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50499       };
50500     }
50501   }
50502 }
50503
50504
50505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50506   void * jresult ;
50507   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50508
50509   {
50510     try {
50511       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50512     } catch (std::out_of_range& e) {
50513       {
50514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50515       };
50516     } catch (std::exception& e) {
50517       {
50518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50519       };
50520     } catch (...) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50523       };
50524     }
50525   }
50526   jresult = (void *)result;
50527   return jresult;
50528 }
50529
50530
50531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50532   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50533
50534   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50535   {
50536     try {
50537       delete arg1;
50538     } catch (std::out_of_range& e) {
50539       {
50540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50541       };
50542     } catch (std::exception& e) {
50543       {
50544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50545       };
50546     } catch (...) {
50547       {
50548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50549       };
50550     }
50551   }
50552 }
50553
50554
50555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50556   void * jresult ;
50557   Dali::Timer *result = 0 ;
50558
50559   {
50560     try {
50561       result = (Dali::Timer *)new Dali::Timer();
50562     } catch (std::out_of_range& e) {
50563       {
50564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50565       };
50566     } catch (std::exception& e) {
50567       {
50568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50569       };
50570     } catch (...) {
50571       {
50572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50573       };
50574     }
50575   }
50576   jresult = (void *)result;
50577   return jresult;
50578 }
50579
50580
50581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50582   void * jresult ;
50583   unsigned int arg1 ;
50584   Dali::Timer result;
50585
50586   arg1 = (unsigned int)jarg1;
50587   {
50588     try {
50589       result = Dali::Timer::New(arg1);
50590     } catch (std::out_of_range& e) {
50591       {
50592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50593       };
50594     } catch (std::exception& e) {
50595       {
50596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50597       };
50598     } catch (...) {
50599       {
50600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50601       };
50602     }
50603   }
50604   jresult = new Dali::Timer((const Dali::Timer &)result);
50605   return jresult;
50606 }
50607
50608
50609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50610   void * jresult ;
50611   Dali::Timer *arg1 = 0 ;
50612   Dali::Timer *result = 0 ;
50613
50614   arg1 = (Dali::Timer *)jarg1;
50615   if (!arg1) {
50616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50617     return 0;
50618   }
50619   {
50620     try {
50621       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50622     } catch (std::out_of_range& e) {
50623       {
50624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50625       };
50626     } catch (std::exception& e) {
50627       {
50628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50629       };
50630     } catch (...) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50633       };
50634     }
50635   }
50636   jresult = (void *)result;
50637   return jresult;
50638 }
50639
50640
50641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50642   void * jresult ;
50643   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50644   Dali::Timer *arg2 = 0 ;
50645   Dali::Timer *result = 0 ;
50646
50647   arg1 = (Dali::Timer *)jarg1;
50648   arg2 = (Dali::Timer *)jarg2;
50649   if (!arg2) {
50650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50651     return 0;
50652   }
50653   {
50654     try {
50655       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50656     } catch (std::out_of_range& e) {
50657       {
50658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50659       };
50660     } catch (std::exception& e) {
50661       {
50662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50667       };
50668     }
50669   }
50670   jresult = (void *)result;
50671   return jresult;
50672 }
50673
50674
50675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50676   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50677
50678   arg1 = (Dali::Timer *)jarg1;
50679   {
50680     try {
50681       delete arg1;
50682     } catch (std::out_of_range& e) {
50683       {
50684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50685       };
50686     } catch (std::exception& e) {
50687       {
50688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50689       };
50690     } catch (...) {
50691       {
50692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50693       };
50694     }
50695   }
50696 }
50697
50698
50699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50700   void * jresult ;
50701   Dali::BaseHandle arg1 ;
50702   Dali::BaseHandle *argp1 ;
50703   Dali::Timer result;
50704
50705   argp1 = (Dali::BaseHandle *)jarg1;
50706   if (!argp1) {
50707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50708     return 0;
50709   }
50710   arg1 = *argp1;
50711   {
50712     try {
50713       result = Dali::Timer::DownCast(arg1);
50714     } catch (std::out_of_range& e) {
50715       {
50716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50717       };
50718     } catch (std::exception& e) {
50719       {
50720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50721       };
50722     } catch (...) {
50723       {
50724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50725       };
50726     }
50727   }
50728   jresult = new Dali::Timer((const Dali::Timer &)result);
50729   return jresult;
50730 }
50731
50732
50733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50734   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50735
50736   arg1 = (Dali::Timer *)jarg1;
50737   {
50738     try {
50739       (arg1)->Start();
50740     } catch (std::out_of_range& e) {
50741       {
50742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50743       };
50744     } catch (std::exception& e) {
50745       {
50746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50747       };
50748     } catch (...) {
50749       {
50750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50751       };
50752     }
50753   }
50754 }
50755
50756
50757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50758   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50759
50760   arg1 = (Dali::Timer *)jarg1;
50761   {
50762     try {
50763       (arg1)->Stop();
50764     } catch (std::out_of_range& e) {
50765       {
50766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50767       };
50768     } catch (std::exception& e) {
50769       {
50770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50771       };
50772     } catch (...) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50775       };
50776     }
50777   }
50778 }
50779
50780
50781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50782   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50783   unsigned int arg2 ;
50784
50785   arg1 = (Dali::Timer *)jarg1;
50786   arg2 = (unsigned int)jarg2;
50787   {
50788     try {
50789       (arg1)->SetInterval(arg2);
50790     } catch (std::out_of_range& e) {
50791       {
50792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50793       };
50794     } catch (std::exception& e) {
50795       {
50796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50797       };
50798     } catch (...) {
50799       {
50800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50801       };
50802     }
50803   }
50804 }
50805
50806
50807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50808   unsigned int jresult ;
50809   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50810   unsigned int result;
50811
50812   arg1 = (Dali::Timer *)jarg1;
50813   {
50814     try {
50815       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50816     } catch (std::out_of_range& e) {
50817       {
50818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50819       };
50820     } catch (std::exception& e) {
50821       {
50822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50823       };
50824     } catch (...) {
50825       {
50826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50827       };
50828     }
50829   }
50830   jresult = result;
50831   return jresult;
50832 }
50833
50834
50835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50836   unsigned int jresult ;
50837   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50838   bool result;
50839
50840   arg1 = (Dali::Timer *)jarg1;
50841   {
50842     try {
50843       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50844     } catch (std::out_of_range& e) {
50845       {
50846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50847       };
50848     } catch (std::exception& e) {
50849       {
50850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50851       };
50852     } catch (...) {
50853       {
50854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50855       };
50856     }
50857   }
50858   jresult = result;
50859   return jresult;
50860 }
50861
50862
50863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50864   void * jresult ;
50865   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50866   Dali::Timer::TimerSignalType *result = 0 ;
50867
50868   arg1 = (Dali::Timer *)jarg1;
50869   {
50870     try {
50871       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50872     } catch (std::out_of_range& e) {
50873       {
50874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50875       };
50876     } catch (std::exception& e) {
50877       {
50878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50879       };
50880     } catch (...) {
50881       {
50882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50883       };
50884     }
50885   }
50886   jresult = (void *)result;
50887   return jresult;
50888 }
50889
50890
50891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50892   void * jresult ;
50893   Dali::DragAndDropDetector *result = 0 ;
50894
50895   {
50896     try {
50897       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50898     } catch (std::out_of_range& e) {
50899       {
50900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50901       };
50902     } catch (std::exception& e) {
50903       {
50904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50905       };
50906     } catch (...) {
50907       {
50908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50909       };
50910     }
50911   }
50912   jresult = (void *)result;
50913   return jresult;
50914 }
50915
50916
50917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50918   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50919
50920   arg1 = (Dali::DragAndDropDetector *)jarg1;
50921   {
50922     try {
50923       delete arg1;
50924     } catch (std::out_of_range& e) {
50925       {
50926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50927       };
50928     } catch (std::exception& e) {
50929       {
50930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50931       };
50932     } catch (...) {
50933       {
50934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50935       };
50936     }
50937   }
50938 }
50939
50940
50941 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50942   char * jresult ;
50943   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50944   std::string *result = 0 ;
50945
50946   arg1 = (Dali::DragAndDropDetector *)jarg1;
50947   {
50948     try {
50949       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50950     } catch (std::out_of_range& e) {
50951       {
50952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50953       };
50954     } catch (std::exception& e) {
50955       {
50956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50957       };
50958     } catch (...) {
50959       {
50960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50961       };
50962     }
50963   }
50964   jresult = SWIG_csharp_string_callback(result->c_str());
50965   return jresult;
50966 }
50967
50968
50969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
50970   void * jresult ;
50971   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50972   Dali::Vector2 result;
50973
50974   arg1 = (Dali::DragAndDropDetector *)jarg1;
50975   {
50976     try {
50977       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
50978     } catch (std::out_of_range& e) {
50979       {
50980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50981       };
50982     } catch (std::exception& e) {
50983       {
50984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50985       };
50986     } catch (...) {
50987       {
50988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50989       };
50990     }
50991   }
50992   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
50993   return jresult;
50994 }
50995
50996
50997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
50998   void * jresult ;
50999   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51000   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51001
51002   arg1 = (Dali::DragAndDropDetector *)jarg1;
51003   {
51004     try {
51005       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51006     } catch (std::out_of_range& e) {
51007       {
51008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51009       };
51010     } catch (std::exception& e) {
51011       {
51012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51013       };
51014     } catch (...) {
51015       {
51016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51017       };
51018     }
51019   }
51020   jresult = (void *)result;
51021   return jresult;
51022 }
51023
51024
51025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51026   void * jresult ;
51027   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51028   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51029
51030   arg1 = (Dali::DragAndDropDetector *)jarg1;
51031   {
51032     try {
51033       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51034     } catch (std::out_of_range& e) {
51035       {
51036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51037       };
51038     } catch (std::exception& e) {
51039       {
51040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51041       };
51042     } catch (...) {
51043       {
51044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51045       };
51046     }
51047   }
51048   jresult = (void *)result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51054   void * jresult ;
51055   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51056   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51057
51058   arg1 = (Dali::DragAndDropDetector *)jarg1;
51059   {
51060     try {
51061       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
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_DragAndDropDetector_DroppedSignal(void * jarg1) {
51082   void * jresult ;
51083   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51084   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51085
51086   arg1 = (Dali::DragAndDropDetector *)jarg1;
51087   {
51088     try {
51089       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51090     } catch (std::out_of_range& e) {
51091       {
51092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51093       };
51094     } catch (std::exception& e) {
51095       {
51096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51097       };
51098     } catch (...) {
51099       {
51100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51101       };
51102     }
51103   }
51104   jresult = (void *)result;
51105   return jresult;
51106 }
51107
51108
51109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51110   void * jresult ;
51111   Dali::ApplicationExtensions *result = 0 ;
51112
51113   {
51114     try {
51115       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51116     } catch (std::out_of_range& e) {
51117       {
51118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51119       };
51120     } catch (std::exception& e) {
51121       {
51122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51123       };
51124     } catch (...) {
51125       {
51126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51127       };
51128     }
51129   }
51130   jresult = (void *)result;
51131   return jresult;
51132 }
51133
51134
51135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51136   void * jresult ;
51137   Dali::Application *arg1 = (Dali::Application *) 0 ;
51138   Dali::ApplicationExtensions *result = 0 ;
51139
51140   arg1 = (Dali::Application *)jarg1;
51141   {
51142     try {
51143       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51144     } catch (std::out_of_range& e) {
51145       {
51146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (std::exception& e) {
51149       {
51150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51155       };
51156     }
51157   }
51158   jresult = (void *)result;
51159   return jresult;
51160 }
51161
51162
51163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51164   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51165
51166   arg1 = (Dali::ApplicationExtensions *)jarg1;
51167   {
51168     try {
51169       delete arg1;
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_ApplicationExtensions_Init(void * jarg1) {
51188   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51189
51190   arg1 = (Dali::ApplicationExtensions *)jarg1;
51191   {
51192     try {
51193       (arg1)->Init();
51194     } catch (std::out_of_range& e) {
51195       {
51196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51197       };
51198     } catch (std::exception& e) {
51199       {
51200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51201       };
51202     } catch (...) {
51203       {
51204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51205       };
51206     }
51207   }
51208 }
51209
51210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51211   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51212
51213   arg1 = (Dali::ApplicationExtensions *)jarg1;
51214   {
51215     try {
51216       (arg1)->Start();
51217     } catch (std::out_of_range& e) {
51218       {
51219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51220       };
51221     } catch (std::exception& e) {
51222       {
51223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51224       };
51225     } catch (...) {
51226       {
51227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51228       };
51229     }
51230   }
51231 }
51232
51233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51234   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51235
51236   arg1 = (Dali::ApplicationExtensions *)jarg1;
51237   {
51238     try {
51239       (arg1)->Terminate();
51240     } catch (std::out_of_range& e) {
51241       {
51242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51243       };
51244     } catch (std::exception& e) {
51245       {
51246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51247       };
51248     } catch (...) {
51249       {
51250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51251       };
51252     }
51253   }
51254 }
51255
51256
51257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51258   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51259
51260   arg1 = (Dali::ApplicationExtensions *)jarg1;
51261   {
51262     try {
51263       (arg1)->Pause();
51264     } catch (std::out_of_range& e) {
51265       {
51266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51267       };
51268     } catch (std::exception& e) {
51269       {
51270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51271       };
51272     } catch (...) {
51273       {
51274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51275       };
51276     }
51277   }
51278 }
51279
51280
51281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51282   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51283
51284   arg1 = (Dali::ApplicationExtensions *)jarg1;
51285   {
51286     try {
51287       (arg1)->Resume();
51288     } catch (std::out_of_range& e) {
51289       {
51290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51291       };
51292     } catch (std::exception& e) {
51293       {
51294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51295       };
51296     } catch (...) {
51297       {
51298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51299       };
51300     }
51301   }
51302 }
51303
51304
51305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51306   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51307
51308   arg1 = (Dali::ApplicationExtensions *)jarg1;
51309   {
51310     try {
51311       (arg1)->LanguageChange();
51312     } catch (std::out_of_range& e) {
51313       {
51314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51315       };
51316     } catch (std::exception& e) {
51317       {
51318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51319       };
51320     } catch (...) {
51321       {
51322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51323       };
51324     }
51325   }
51326 }
51327
51328
51329
51330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51331   unsigned int jresult ;
51332   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51333   bool result;
51334
51335   arg1 = (Dali::Signal< bool () > *)jarg1;
51336   {
51337     try {
51338       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51339     } catch (std::out_of_range& e) {
51340       {
51341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51342       };
51343     } catch (std::exception& e) {
51344       {
51345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51346       };
51347     } catch (...) {
51348       {
51349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51350       };
51351     }
51352   }
51353   jresult = result;
51354   return jresult;
51355 }
51356
51357
51358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51359   unsigned long jresult ;
51360   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51361   std::size_t result;
51362
51363   arg1 = (Dali::Signal< bool () > *)jarg1;
51364   {
51365     try {
51366       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51367     } catch (std::out_of_range& e) {
51368       {
51369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51370       };
51371     } catch (std::exception& e) {
51372       {
51373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51374       };
51375     } catch (...) {
51376       {
51377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51378       };
51379     }
51380   }
51381   jresult = (unsigned long)result;
51382   return jresult;
51383 }
51384
51385
51386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51387   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51388   bool (*arg2)() = (bool (*)()) 0 ;
51389
51390   arg1 = (Dali::Signal< bool () > *)jarg1;
51391   arg2 = (bool (*)())jarg2;
51392   {
51393     try {
51394       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51395     } catch (std::out_of_range& e) {
51396       {
51397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51398       };
51399     } catch (std::exception& e) {
51400       {
51401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51402       };
51403     } catch (...) {
51404       {
51405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51406       };
51407     }
51408   }
51409 }
51410
51411
51412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51413   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51414   bool (*arg2)() = (bool (*)()) 0 ;
51415
51416   arg1 = (Dali::Signal< bool () > *)jarg1;
51417   arg2 = (bool (*)())jarg2;
51418   {
51419     try {
51420       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51421     } catch (std::out_of_range& e) {
51422       {
51423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51424       };
51425     } catch (std::exception& e) {
51426       {
51427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51428       };
51429     } catch (...) {
51430       {
51431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51432       };
51433     }
51434   }
51435 }
51436
51437
51438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51439   unsigned int jresult ;
51440   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51441   bool result;
51442
51443   arg1 = (Dali::Signal< bool () > *)jarg1;
51444   {
51445     try {
51446       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51447     } catch (std::out_of_range& e) {
51448       {
51449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51450       };
51451     } catch (std::exception& e) {
51452       {
51453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51454       };
51455     } catch (...) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51458       };
51459     }
51460   }
51461   jresult = result;
51462   return jresult;
51463 }
51464
51465
51466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51467   void * jresult ;
51468   Dali::Signal< bool () > *result = 0 ;
51469
51470   {
51471     try {
51472       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51473     } catch (std::out_of_range& e) {
51474       {
51475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51476       };
51477     } catch (std::exception& e) {
51478       {
51479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51484       };
51485     }
51486   }
51487   jresult = (void *)result;
51488   return jresult;
51489 }
51490
51491
51492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51493   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51494
51495   arg1 = (Dali::Signal< bool () > *)jarg1;
51496   {
51497     try {
51498       delete arg1;
51499     } catch (std::out_of_range& e) {
51500       {
51501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51502       };
51503     } catch (std::exception& e) {
51504       {
51505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51506       };
51507     } catch (...) {
51508       {
51509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51510       };
51511     }
51512   }
51513 }
51514
51515
51516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51517   int jresult ;
51518   int result;
51519
51520   {
51521     try {
51522       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51523     } catch (std::out_of_range& e) {
51524       {
51525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51526       };
51527     } catch (std::exception& e) {
51528       {
51529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51530       };
51531     } catch (...) {
51532       {
51533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51534       };
51535     }
51536   }
51537   jresult = (int)result;
51538   return jresult;
51539 }
51540
51541
51542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51543   int jresult ;
51544   int result;
51545
51546   {
51547     try {
51548       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51549     } catch (std::out_of_range& e) {
51550       {
51551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51552       };
51553     } catch (std::exception& e) {
51554       {
51555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51556       };
51557     } catch (...) {
51558       {
51559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51560       };
51561     }
51562   }
51563   jresult = (int)result;
51564   return jresult;
51565 }
51566
51567
51568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51569   int jresult ;
51570   int result;
51571
51572   {
51573     try {
51574       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51575     } catch (std::out_of_range& e) {
51576       {
51577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51578       };
51579     } catch (std::exception& e) {
51580       {
51581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51582       };
51583     } catch (...) {
51584       {
51585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51586       };
51587     }
51588   }
51589   jresult = (int)result;
51590   return jresult;
51591 }
51592
51593
51594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51595   int jresult ;
51596   int result;
51597
51598   {
51599     try {
51600       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51601     } catch (std::out_of_range& e) {
51602       {
51603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51604       };
51605     } catch (std::exception& e) {
51606       {
51607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51608       };
51609     } catch (...) {
51610       {
51611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51612       };
51613     }
51614   }
51615   jresult = (int)result;
51616   return jresult;
51617 }
51618
51619
51620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51621   int jresult ;
51622   int result;
51623
51624   {
51625     try {
51626       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51627     } catch (std::out_of_range& e) {
51628       {
51629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51630       };
51631     } catch (std::exception& e) {
51632       {
51633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51634       };
51635     } catch (...) {
51636       {
51637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51638       };
51639     }
51640   }
51641   jresult = (int)result;
51642   return jresult;
51643 }
51644
51645
51646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51647   int jresult ;
51648   int result;
51649
51650   {
51651     try {
51652       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51653     } catch (std::out_of_range& e) {
51654       {
51655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51656       };
51657     } catch (std::exception& e) {
51658       {
51659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51660       };
51661     } catch (...) {
51662       {
51663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51664       };
51665     }
51666   }
51667   jresult = (int)result;
51668   return jresult;
51669 }
51670
51671
51672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51673   int jresult ;
51674   int result;
51675
51676   {
51677     try {
51678       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51679     } catch (std::out_of_range& e) {
51680       {
51681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51682       };
51683     } catch (std::exception& e) {
51684       {
51685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51686       };
51687     } catch (...) {
51688       {
51689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51690       };
51691     }
51692   }
51693   jresult = (int)result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51699   int jresult ;
51700   int result;
51701
51702   {
51703     try {
51704       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51705     } catch (std::out_of_range& e) {
51706       {
51707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51708       };
51709     } catch (std::exception& e) {
51710       {
51711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51712       };
51713     } catch (...) {
51714       {
51715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51716       };
51717     }
51718   }
51719   jresult = (int)result;
51720   return jresult;
51721 }
51722
51723
51724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51725   int jresult ;
51726   int result;
51727
51728   {
51729     try {
51730       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51738       };
51739     } catch (...) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51742       };
51743     }
51744   }
51745   jresult = (int)result;
51746   return jresult;
51747 }
51748
51749
51750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51751   int jresult ;
51752   int result;
51753
51754   {
51755     try {
51756       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51757     } catch (std::out_of_range& e) {
51758       {
51759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51760       };
51761     } catch (std::exception& e) {
51762       {
51763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51764       };
51765     } catch (...) {
51766       {
51767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51768       };
51769     }
51770   }
51771   jresult = (int)result;
51772   return jresult;
51773 }
51774
51775
51776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51777   int jresult ;
51778   int result;
51779
51780   {
51781     try {
51782       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51783     } catch (std::out_of_range& e) {
51784       {
51785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (std::exception& e) {
51788       {
51789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (...) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51794       };
51795     }
51796   }
51797   jresult = (int)result;
51798   return jresult;
51799 }
51800
51801
51802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51803   int jresult ;
51804   int result;
51805
51806   {
51807     try {
51808       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51809     } catch (std::out_of_range& e) {
51810       {
51811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51812       };
51813     } catch (std::exception& e) {
51814       {
51815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51816       };
51817     } catch (...) {
51818       {
51819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51820       };
51821     }
51822   }
51823   jresult = (int)result;
51824   return jresult;
51825 }
51826
51827
51828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51829   int jresult ;
51830   int result;
51831
51832   {
51833     try {
51834       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51835     } catch (std::out_of_range& e) {
51836       {
51837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51838       };
51839     } catch (std::exception& e) {
51840       {
51841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51842       };
51843     } catch (...) {
51844       {
51845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51846       };
51847     }
51848   }
51849   jresult = (int)result;
51850   return jresult;
51851 }
51852
51853
51854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51855   int jresult ;
51856   int result;
51857
51858   {
51859     try {
51860       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51861     } catch (std::out_of_range& e) {
51862       {
51863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51864       };
51865     } catch (std::exception& e) {
51866       {
51867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51868       };
51869     } catch (...) {
51870       {
51871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51872       };
51873     }
51874   }
51875   jresult = (int)result;
51876   return jresult;
51877 }
51878
51879
51880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51881   int jresult ;
51882   int result;
51883
51884   {
51885     try {
51886       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51887     } catch (std::out_of_range& e) {
51888       {
51889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (std::exception& e) {
51892       {
51893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51894       };
51895     } catch (...) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51898       };
51899     }
51900   }
51901   jresult = (int)result;
51902   return jresult;
51903 }
51904
51905
51906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51907   int jresult ;
51908   int result;
51909
51910   {
51911     try {
51912       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51913     } catch (std::out_of_range& e) {
51914       {
51915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51916       };
51917     } catch (std::exception& e) {
51918       {
51919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51920       };
51921     } catch (...) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51924       };
51925     }
51926   }
51927   jresult = (int)result;
51928   return jresult;
51929 }
51930
51931
51932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51933   int jresult ;
51934   int result;
51935
51936   {
51937     try {
51938       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51939     } catch (std::out_of_range& e) {
51940       {
51941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51942       };
51943     } catch (std::exception& e) {
51944       {
51945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51950       };
51951     }
51952   }
51953   jresult = (int)result;
51954   return jresult;
51955 }
51956
51957
51958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
51959   int jresult ;
51960   int result;
51961
51962   {
51963     try {
51964       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51972       };
51973     } catch (...) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51976       };
51977     }
51978   }
51979   jresult = (int)result;
51980   return jresult;
51981 }
51982
51983
51984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
51985   int jresult ;
51986   int result;
51987
51988   {
51989     try {
51990       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
51991     } catch (std::out_of_range& e) {
51992       {
51993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51994       };
51995     } catch (std::exception& e) {
51996       {
51997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51998       };
51999     } catch (...) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52002       };
52003     }
52004   }
52005   jresult = (int)result;
52006   return jresult;
52007 }
52008
52009
52010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52011   int jresult ;
52012   int result;
52013
52014   {
52015     try {
52016       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52017     } catch (std::out_of_range& e) {
52018       {
52019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52020       };
52021     } catch (std::exception& e) {
52022       {
52023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52024       };
52025     } catch (...) {
52026       {
52027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52028       };
52029     }
52030   }
52031   jresult = (int)result;
52032   return jresult;
52033 }
52034
52035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52036   int jresult ;
52037   int result;
52038
52039   {
52040     try {
52041       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
52042     } catch (std::out_of_range& e) {
52043       {
52044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52045       };
52046     } catch (std::exception& e) {
52047       {
52048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52049       };
52050     } catch (...) {
52051       {
52052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52053       };
52054     }
52055   }
52056   jresult = (int)result;
52057   return jresult;
52058 }
52059
52060
52061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52062   int jresult ;
52063   int result;
52064   {
52065     try
52066     {
52067       result = (int)Dali::Toolkit::DevelImageVisual::Property::BATCH_SIZE;
52068     } catch (std::out_of_range& e) {
52069       {
52070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52071       };
52072     } catch (std::exception& e) {
52073       {
52074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52075       };
52076     } catch (...) {
52077       {
52078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52079       };
52080     }
52081   }
52082   jresult = (int)result;
52083   return jresult;
52084 }
52085
52086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52087   int jresult ;
52088   int result;
52089   {
52090     try
52091     {
52092       result = (int)Dali::Toolkit::DevelImageVisual::Property::CACHE_SIZE;
52093     } catch (std::out_of_range& e) {
52094       {
52095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52096       };
52097     } catch (std::exception& e) {
52098       {
52099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52100       };
52101     } catch (...) {
52102       {
52103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52104       };
52105     }
52106   }
52107   jresult = (int)result;
52108   return jresult;
52109 }
52110
52111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52112   int jresult ;
52113   int result;
52114   {
52115     try
52116     {
52117       result = (int)Dali::Toolkit::DevelImageVisual::Property::FRAME_DELAY;
52118     } catch (std::out_of_range& e) {
52119       {
52120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52121       };
52122     } catch (std::exception& e) {
52123       {
52124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52125       };
52126     } catch (...) {
52127       {
52128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52129       };
52130     }
52131   }
52132   jresult = (int)result;
52133   return jresult;
52134 }
52135
52136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52137   int jresult ;
52138   int result;
52139   {
52140     try
52141     {
52142       result = (int)Dali::Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE;
52143     } catch (std::out_of_range& e) {
52144       {
52145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52146       };
52147     } catch (std::exception& e) {
52148       {
52149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52150       };
52151     } catch (...) {
52152       {
52153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52154       };
52155     }
52156   }
52157   jresult = (int)result;
52158   return jresult;
52159 }
52160
52161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52162   int jresult ;
52163   int result;
52164   {
52165     try
52166     {
52167       result = (int)Dali::Toolkit::DevelImageVisual::Property::CROP_TO_MASK;
52168     } catch (std::out_of_range& e) {
52169       {
52170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52171       };
52172     } catch (std::exception& e) {
52173       {
52174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52175       };
52176     } catch (...) {
52177       {
52178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52179       };
52180     }
52181   }
52182   jresult = (int)result;
52183   return jresult;
52184 }
52185
52186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52187   int jresult ;
52188   int result;
52189
52190   {
52191     try {
52192       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52193     } catch (std::out_of_range& e) {
52194       {
52195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52196       };
52197     } catch (std::exception& e) {
52198       {
52199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (...) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52204       };
52205     }
52206   }
52207   jresult = (int)result;
52208   return jresult;
52209 }
52210
52211
52212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52213   int jresult ;
52214   int result;
52215
52216   {
52217     try {
52218       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52219     } catch (std::out_of_range& e) {
52220       {
52221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52222       };
52223     } catch (std::exception& e) {
52224       {
52225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52230       };
52231     }
52232   }
52233   jresult = (int)result;
52234   return jresult;
52235 }
52236
52237
52238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52239   int jresult ;
52240   int result;
52241
52242   {
52243     try {
52244       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52245     } catch (std::out_of_range& e) {
52246       {
52247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (std::exception& e) {
52250       {
52251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52252       };
52253     } catch (...) {
52254       {
52255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52256       };
52257     }
52258   }
52259   jresult = (int)result;
52260   return jresult;
52261 }
52262
52263
52264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52265   int jresult ;
52266   int result;
52267
52268   {
52269     try {
52270       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52271     } catch (std::out_of_range& e) {
52272       {
52273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52274       };
52275     } catch (std::exception& e) {
52276       {
52277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52278       };
52279     } catch (...) {
52280       {
52281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52282       };
52283     }
52284   }
52285   jresult = (int)result;
52286   return jresult;
52287 }
52288
52289
52290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52291   int jresult ;
52292   int result;
52293
52294   {
52295     try {
52296       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52297     } catch (std::out_of_range& e) {
52298       {
52299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52300       };
52301     } catch (std::exception& e) {
52302       {
52303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52304       };
52305     } catch (...) {
52306       {
52307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52308       };
52309     }
52310   }
52311   jresult = (int)result;
52312   return jresult;
52313 }
52314
52315
52316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52317   int jresult ;
52318   int result;
52319
52320   {
52321     try {
52322       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52323     } catch (std::out_of_range& e) {
52324       {
52325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52326       };
52327     } catch (std::exception& e) {
52328       {
52329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52330       };
52331     } catch (...) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52334       };
52335     }
52336   }
52337   jresult = (int)result;
52338   return jresult;
52339 }
52340
52341
52342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52343   int jresult ;
52344   int result;
52345
52346   {
52347     try {
52348       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52349     } catch (std::out_of_range& e) {
52350       {
52351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52352       };
52353     } catch (std::exception& e) {
52354       {
52355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52356       };
52357     } catch (...) {
52358       {
52359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52360       };
52361     }
52362   }
52363   jresult = (int)result;
52364   return jresult;
52365 }
52366
52367
52368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52369   int jresult ;
52370   int result;
52371
52372   {
52373     try {
52374       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52375     } catch (std::out_of_range& e) {
52376       {
52377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52378       };
52379     } catch (std::exception& e) {
52380       {
52381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52382       };
52383     } catch (...) {
52384       {
52385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52386       };
52387     }
52388   }
52389   jresult = (int)result;
52390   return jresult;
52391 }
52392
52393
52394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52395   int jresult ;
52396   int result;
52397
52398   {
52399     try {
52400       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52401     } catch (std::out_of_range& e) {
52402       {
52403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52404       };
52405     } catch (std::exception& e) {
52406       {
52407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52408       };
52409     } catch (...) {
52410       {
52411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52412       };
52413     }
52414   }
52415   jresult = (int)result;
52416   return jresult;
52417 }
52418
52419
52420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52421   int jresult ;
52422   int result;
52423
52424   {
52425     try {
52426       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52427     } catch (std::out_of_range& e) {
52428       {
52429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52430       };
52431     } catch (std::exception& e) {
52432       {
52433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52434       };
52435     } catch (...) {
52436       {
52437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52438       };
52439     }
52440   }
52441   jresult = (int)result;
52442   return jresult;
52443 }
52444
52445
52446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52447   int jresult ;
52448   int result;
52449
52450   {
52451     try {
52452       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52453     } catch (std::out_of_range& e) {
52454       {
52455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52456       };
52457     } catch (std::exception& e) {
52458       {
52459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52460       };
52461     } catch (...) {
52462       {
52463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52464       };
52465     }
52466   }
52467   jresult = (int)result;
52468   return jresult;
52469 }
52470
52471
52472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52473   int jresult ;
52474   int result;
52475
52476   {
52477     try {
52478       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52479     } catch (std::out_of_range& e) {
52480       {
52481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52482       };
52483     } catch (std::exception& e) {
52484       {
52485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (...) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52490       };
52491     }
52492   }
52493   jresult = (int)result;
52494   return jresult;
52495 }
52496
52497
52498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52499   int jresult ;
52500   int result;
52501
52502   {
52503     try {
52504       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52505     } catch (std::out_of_range& e) {
52506       {
52507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52508       };
52509     } catch (std::exception& e) {
52510       {
52511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52512       };
52513     } catch (...) {
52514       {
52515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52516       };
52517     }
52518   }
52519   jresult = (int)result;
52520   return jresult;
52521 }
52522
52523
52524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52525   int jresult ;
52526   int result;
52527
52528   {
52529     try {
52530       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52531     } catch (std::out_of_range& e) {
52532       {
52533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52534       };
52535     } catch (std::exception& e) {
52536       {
52537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52538       };
52539     } catch (...) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52542       };
52543     }
52544   }
52545   jresult = (int)result;
52546   return jresult;
52547 }
52548
52549
52550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52551   int jresult ;
52552   int result;
52553
52554   {
52555     try {
52556       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52557     } catch (std::out_of_range& e) {
52558       {
52559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52560       };
52561     } catch (std::exception& e) {
52562       {
52563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52564       };
52565     } catch (...) {
52566       {
52567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52568       };
52569     }
52570   }
52571   jresult = (int)result;
52572   return jresult;
52573 }
52574
52575
52576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52577   int jresult ;
52578   int result;
52579
52580   {
52581     try {
52582       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52583     } catch (std::out_of_range& e) {
52584       {
52585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52586       };
52587     } catch (std::exception& e) {
52588       {
52589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52590       };
52591     } catch (...) {
52592       {
52593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52594       };
52595     }
52596   }
52597   jresult = (int)result;
52598   return jresult;
52599 }
52600
52601
52602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52603   int jresult ;
52604   int result;
52605
52606   {
52607     try {
52608       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52609     } catch (std::out_of_range& e) {
52610       {
52611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52612       };
52613     } catch (std::exception& e) {
52614       {
52615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52616       };
52617     } catch (...) {
52618       {
52619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52620       };
52621     }
52622   }
52623   jresult = (int)result;
52624   return jresult;
52625 }
52626
52627
52628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52629   int jresult ;
52630   int result;
52631
52632   {
52633     try {
52634       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52635     } catch (std::out_of_range& e) {
52636       {
52637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52638       };
52639     } catch (std::exception& e) {
52640       {
52641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52642       };
52643     } catch (...) {
52644       {
52645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52646       };
52647     }
52648   }
52649   jresult = (int)result;
52650   return jresult;
52651 }
52652
52653
52654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52655   int jresult ;
52656   int result;
52657
52658   {
52659     try {
52660       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52661     } catch (std::out_of_range& e) {
52662       {
52663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52664       };
52665     } catch (std::exception& e) {
52666       {
52667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52668       };
52669     } catch (...) {
52670       {
52671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52672       };
52673     }
52674   }
52675   jresult = (int)result;
52676   return jresult;
52677 }
52678
52679
52680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52681   int jresult ;
52682   int result;
52683
52684   {
52685     try {
52686       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52687     } catch (std::out_of_range& e) {
52688       {
52689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52690       };
52691     } catch (std::exception& e) {
52692       {
52693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52694       };
52695     } catch (...) {
52696       {
52697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52698       };
52699     }
52700   }
52701   jresult = (int)result;
52702   return jresult;
52703 }
52704
52705
52706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52707   int jresult ;
52708   int result;
52709
52710   {
52711     try {
52712       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52713     } catch (std::out_of_range& e) {
52714       {
52715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52716       };
52717     } catch (std::exception& e) {
52718       {
52719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52720       };
52721     } catch (...) {
52722       {
52723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52724       };
52725     }
52726   }
52727   jresult = (int)result;
52728   return jresult;
52729 }
52730
52731
52732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52733   int jresult ;
52734   int result;
52735
52736   {
52737     try {
52738       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52739     } catch (std::out_of_range& e) {
52740       {
52741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (std::exception& e) {
52744       {
52745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52746       };
52747     } catch (...) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52750       };
52751     }
52752   }
52753   jresult = (int)result;
52754   return jresult;
52755 }
52756
52757
52758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52759   int jresult ;
52760   int result;
52761
52762   {
52763     try {
52764       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52765     } catch (std::out_of_range& e) {
52766       {
52767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52768       };
52769     } catch (std::exception& e) {
52770       {
52771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52772       };
52773     } catch (...) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52776       };
52777     }
52778   }
52779   jresult = (int)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52785   int jresult ;
52786   int result;
52787
52788   {
52789     try {
52790       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52791     } catch (std::out_of_range& e) {
52792       {
52793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52794       };
52795     } catch (std::exception& e) {
52796       {
52797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52798       };
52799     } catch (...) {
52800       {
52801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52802       };
52803     }
52804   }
52805   jresult = (int)result;
52806   return jresult;
52807 }
52808
52809
52810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52811   int jresult ;
52812   int result;
52813
52814   {
52815     try {
52816       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52817     } catch (std::out_of_range& e) {
52818       {
52819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (std::exception& e) {
52822       {
52823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52824       };
52825     } catch (...) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52828       };
52829     }
52830   }
52831   jresult = (int)result;
52832   return jresult;
52833 }
52834
52835
52836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52837   int jresult ;
52838   int result;
52839
52840   {
52841     try {
52842       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52843     } catch (std::out_of_range& e) {
52844       {
52845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52846       };
52847     } catch (std::exception& e) {
52848       {
52849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52850       };
52851     } catch (...) {
52852       {
52853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52854       };
52855     }
52856   }
52857   jresult = (int)result;
52858   return jresult;
52859 }
52860
52861
52862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52863   int jresult ;
52864   int result;
52865
52866   {
52867     try {
52868       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52869     } catch (std::out_of_range& e) {
52870       {
52871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52872       };
52873     } catch (std::exception& e) {
52874       {
52875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52876       };
52877     } catch (...) {
52878       {
52879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52880       };
52881     }
52882   }
52883   jresult = (int)result;
52884   return jresult;
52885 }
52886
52887
52888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52889   int jresult ;
52890   int result;
52891
52892   {
52893     try {
52894       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52895     } catch (std::out_of_range& e) {
52896       {
52897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52898       };
52899     } catch (std::exception& e) {
52900       {
52901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (...) {
52904       {
52905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52906       };
52907     }
52908   }
52909   jresult = (int)result;
52910   return jresult;
52911 }
52912
52913
52914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52915   int jresult ;
52916   int result;
52917
52918   {
52919     try {
52920       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52921     } catch (std::out_of_range& e) {
52922       {
52923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52924       };
52925     } catch (std::exception& e) {
52926       {
52927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52928       };
52929     } catch (...) {
52930       {
52931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52932       };
52933     }
52934   }
52935   jresult = (int)result;
52936   return jresult;
52937 }
52938
52939
52940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52941   int jresult ;
52942   int result;
52943
52944   {
52945     try {
52946       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52947     } catch (std::out_of_range& e) {
52948       {
52949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52950       };
52951     } catch (std::exception& e) {
52952       {
52953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52954       };
52955     } catch (...) {
52956       {
52957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52958       };
52959     }
52960   }
52961   jresult = (int)result;
52962   return jresult;
52963 }
52964
52965
52966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
52967   int jresult ;
52968   int result;
52969
52970   {
52971     try {
52972       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52980       };
52981     } catch (...) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52984       };
52985     }
52986   }
52987   jresult = (int)result;
52988   return jresult;
52989 }
52990
52991
52992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
52993   int jresult ;
52994   int result;
52995
52996   {
52997     try {
52998       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
52999     } catch (std::out_of_range& e) {
53000       {
53001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53002       };
53003     } catch (std::exception& e) {
53004       {
53005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53006       };
53007     } catch (...) {
53008       {
53009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53010       };
53011     }
53012   }
53013   jresult = (int)result;
53014   return jresult;
53015 }
53016
53017
53018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53019   int jresult ;
53020   int result;
53021
53022   {
53023     try {
53024       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53032       };
53033     } catch (...) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53036       };
53037     }
53038   }
53039   jresult = (int)result;
53040   return jresult;
53041 }
53042
53043
53044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53045   int jresult ;
53046   int result;
53047
53048   {
53049     try {
53050       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53051     } catch (std::out_of_range& e) {
53052       {
53053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (std::exception& e) {
53056       {
53057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065   jresult = (int)result;
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53071   int jresult ;
53072   int result;
53073
53074   {
53075     try {
53076       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53088       };
53089     }
53090   }
53091   jresult = (int)result;
53092   return jresult;
53093 }
53094
53095
53096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53097   int jresult ;
53098   int result;
53099
53100   {
53101     try {
53102       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53103     } catch (std::out_of_range& e) {
53104       {
53105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53106       };
53107     } catch (std::exception& e) {
53108       {
53109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53110       };
53111     } catch (...) {
53112       {
53113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53114       };
53115     }
53116   }
53117   jresult = (int)result;
53118   return jresult;
53119 }
53120
53121
53122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53123   int jresult ;
53124   int result;
53125
53126   {
53127     try {
53128       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53129     } catch (std::out_of_range& e) {
53130       {
53131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53132       };
53133     } catch (std::exception& e) {
53134       {
53135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53136       };
53137     } catch (...) {
53138       {
53139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53140       };
53141     }
53142   }
53143   jresult = (int)result;
53144   return jresult;
53145 }
53146
53147
53148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53149   void * jresult ;
53150   Dali::Toolkit::Builder *result = 0 ;
53151
53152   {
53153     try {
53154       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53155     } catch (std::out_of_range& e) {
53156       {
53157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (std::exception& e) {
53160       {
53161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (...) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53166       };
53167     }
53168   }
53169   jresult = (void *)result;
53170   return jresult;
53171 }
53172
53173
53174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53175   void * jresult ;
53176   Dali::Toolkit::Builder result;
53177
53178   {
53179     try {
53180       result = Dali::Toolkit::Builder::New();
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53192       };
53193     }
53194   }
53195   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53196   return jresult;
53197 }
53198
53199
53200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53201   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53202
53203   arg1 = (Dali::Toolkit::Builder *)jarg1;
53204   {
53205     try {
53206       delete arg1;
53207     } catch (std::out_of_range& e) {
53208       {
53209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53210       };
53211     } catch (std::exception& e) {
53212       {
53213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53214       };
53215     } catch (...) {
53216       {
53217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53218       };
53219     }
53220   }
53221 }
53222
53223
53224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53225   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53226   std::string *arg2 = 0 ;
53227   Dali::Toolkit::Builder::UIFormat arg3 ;
53228
53229   arg1 = (Dali::Toolkit::Builder *)jarg1;
53230   if (!jarg2) {
53231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53232     return ;
53233   }
53234   std::string arg2_str(jarg2);
53235   arg2 = &arg2_str;
53236   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53237   {
53238     try {
53239       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53240     } catch (std::out_of_range& e) {
53241       {
53242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53243       };
53244     } catch (std::exception& e) {
53245       {
53246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53247       };
53248     } catch (...) {
53249       {
53250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53251       };
53252     }
53253   }
53254
53255   //argout typemap for const std::string&
53256
53257 }
53258
53259
53260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53261   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53262   std::string *arg2 = 0 ;
53263
53264   arg1 = (Dali::Toolkit::Builder *)jarg1;
53265   if (!jarg2) {
53266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53267     return ;
53268   }
53269   std::string arg2_str(jarg2);
53270   arg2 = &arg2_str;
53271   {
53272     try {
53273       (arg1)->LoadFromString((std::string const &)*arg2);
53274     } catch (std::out_of_range& e) {
53275       {
53276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53277       };
53278     } catch (std::exception& e) {
53279       {
53280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53281       };
53282     } catch (...) {
53283       {
53284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53285       };
53286     }
53287   }
53288
53289   //argout typemap for const std::string&
53290
53291 }
53292
53293
53294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53295   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53296   Dali::Property::Map *arg2 = 0 ;
53297
53298   arg1 = (Dali::Toolkit::Builder *)jarg1;
53299   arg2 = (Dali::Property::Map *)jarg2;
53300   if (!arg2) {
53301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53302     return ;
53303   }
53304   {
53305     try {
53306       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53307     } catch (std::out_of_range& e) {
53308       {
53309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53310       };
53311     } catch (std::exception& e) {
53312       {
53313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53314       };
53315     } catch (...) {
53316       {
53317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53318       };
53319     }
53320   }
53321 }
53322
53323
53324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53325   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53326   std::string *arg2 = 0 ;
53327   Dali::Property::Value *arg3 = 0 ;
53328
53329   arg1 = (Dali::Toolkit::Builder *)jarg1;
53330   if (!jarg2) {
53331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53332     return ;
53333   }
53334   std::string arg2_str(jarg2);
53335   arg2 = &arg2_str;
53336   arg3 = (Dali::Property::Value *)jarg3;
53337   if (!arg3) {
53338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53339     return ;
53340   }
53341   {
53342     try {
53343       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53344     } catch (std::out_of_range& e) {
53345       {
53346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53347       };
53348     } catch (std::exception& e) {
53349       {
53350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53351       };
53352     } catch (...) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53355       };
53356     }
53357   }
53358
53359   //argout typemap for const std::string&
53360
53361 }
53362
53363
53364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53365   void * jresult ;
53366   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53367   Dali::Property::Map *result = 0 ;
53368
53369   arg1 = (Dali::Toolkit::Builder *)jarg1;
53370   {
53371     try {
53372       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53373     } catch (std::out_of_range& e) {
53374       {
53375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53376       };
53377     } catch (std::exception& e) {
53378       {
53379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53380       };
53381     } catch (...) {
53382       {
53383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53384       };
53385     }
53386   }
53387   jresult = (void *)result;
53388   return jresult;
53389 }
53390
53391
53392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53393   void * jresult ;
53394   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53395   std::string *arg2 = 0 ;
53396   Dali::Property::Value *result = 0 ;
53397
53398   arg1 = (Dali::Toolkit::Builder *)jarg1;
53399   if (!jarg2) {
53400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53401     return 0;
53402   }
53403   std::string arg2_str(jarg2);
53404   arg2 = &arg2_str;
53405   {
53406     try {
53407       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53408     } catch (std::out_of_range& e) {
53409       {
53410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53411       };
53412     } catch (std::exception& e) {
53413       {
53414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53415       };
53416     } catch (...) {
53417       {
53418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53419       };
53420     }
53421   }
53422   jresult = (void *)result;
53423
53424   //argout typemap for const std::string&
53425
53426   return jresult;
53427 }
53428
53429
53430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53431   void * jresult ;
53432   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53433   std::string *arg2 = 0 ;
53434   Dali::Animation result;
53435
53436   arg1 = (Dali::Toolkit::Builder *)jarg1;
53437   if (!jarg2) {
53438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53439     return 0;
53440   }
53441   std::string arg2_str(jarg2);
53442   arg2 = &arg2_str;
53443   {
53444     try {
53445       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53446     } catch (std::out_of_range& e) {
53447       {
53448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53449       };
53450     } catch (std::exception& e) {
53451       {
53452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53453       };
53454     } catch (...) {
53455       {
53456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53457       };
53458     }
53459   }
53460   jresult = new Dali::Animation((const Dali::Animation &)result);
53461
53462   //argout typemap for const std::string&
53463
53464   return jresult;
53465 }
53466
53467
53468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53469   void * jresult ;
53470   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53471   std::string *arg2 = 0 ;
53472   Dali::Property::Map *arg3 = 0 ;
53473   Dali::Animation result;
53474
53475   arg1 = (Dali::Toolkit::Builder *)jarg1;
53476   if (!jarg2) {
53477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53478     return 0;
53479   }
53480   std::string arg2_str(jarg2);
53481   arg2 = &arg2_str;
53482   arg3 = (Dali::Property::Map *)jarg3;
53483   if (!arg3) {
53484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53485     return 0;
53486   }
53487   {
53488     try {
53489       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53490     } catch (std::out_of_range& e) {
53491       {
53492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53493       };
53494     } catch (std::exception& e) {
53495       {
53496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53497       };
53498     } catch (...) {
53499       {
53500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53501       };
53502     }
53503   }
53504   jresult = new Dali::Animation((const Dali::Animation &)result);
53505
53506   //argout typemap for const std::string&
53507
53508   return jresult;
53509 }
53510
53511
53512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53513   void * jresult ;
53514   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53515   std::string *arg2 = 0 ;
53516   Dali::Actor arg3 ;
53517   Dali::Actor *argp3 ;
53518   Dali::Animation result;
53519
53520   arg1 = (Dali::Toolkit::Builder *)jarg1;
53521   if (!jarg2) {
53522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53523     return 0;
53524   }
53525   std::string arg2_str(jarg2);
53526   arg2 = &arg2_str;
53527   argp3 = (Dali::Actor *)jarg3;
53528   if (!argp3) {
53529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53530     return 0;
53531   }
53532   arg3 = *argp3;
53533   {
53534     try {
53535       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53536     } catch (std::out_of_range& e) {
53537       {
53538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53539       };
53540     } catch (std::exception& e) {
53541       {
53542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53543       };
53544     } catch (...) {
53545       {
53546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53547       };
53548     }
53549   }
53550   jresult = new Dali::Animation((const Dali::Animation &)result);
53551
53552   //argout typemap for const std::string&
53553
53554   return jresult;
53555 }
53556
53557
53558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53559   void * jresult ;
53560   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53561   std::string *arg2 = 0 ;
53562   Dali::Property::Map *arg3 = 0 ;
53563   Dali::Actor arg4 ;
53564   Dali::Actor *argp4 ;
53565   Dali::Animation result;
53566
53567   arg1 = (Dali::Toolkit::Builder *)jarg1;
53568   if (!jarg2) {
53569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53570     return 0;
53571   }
53572   std::string arg2_str(jarg2);
53573   arg2 = &arg2_str;
53574   arg3 = (Dali::Property::Map *)jarg3;
53575   if (!arg3) {
53576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53577     return 0;
53578   }
53579   argp4 = (Dali::Actor *)jarg4;
53580   if (!argp4) {
53581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53582     return 0;
53583   }
53584   arg4 = *argp4;
53585   {
53586     try {
53587       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (...) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53599       };
53600     }
53601   }
53602   jresult = new Dali::Animation((const Dali::Animation &)result);
53603
53604   //argout typemap for const std::string&
53605
53606   return jresult;
53607 }
53608
53609
53610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53611   void * jresult ;
53612   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53613   std::string *arg2 = 0 ;
53614   Dali::BaseHandle result;
53615
53616   arg1 = (Dali::Toolkit::Builder *)jarg1;
53617   if (!jarg2) {
53618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53619     return 0;
53620   }
53621   std::string arg2_str(jarg2);
53622   arg2 = &arg2_str;
53623   {
53624     try {
53625       result = (arg1)->Create((std::string const &)*arg2);
53626     } catch (std::out_of_range& e) {
53627       {
53628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53629       };
53630     } catch (std::exception& e) {
53631       {
53632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53637       };
53638     }
53639   }
53640   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53641
53642   //argout typemap for const std::string&
53643
53644   return jresult;
53645 }
53646
53647
53648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53649   void * jresult ;
53650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53651   std::string *arg2 = 0 ;
53652   Dali::Property::Map *arg3 = 0 ;
53653   Dali::BaseHandle result;
53654
53655   arg1 = (Dali::Toolkit::Builder *)jarg1;
53656   if (!jarg2) {
53657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53658     return 0;
53659   }
53660   std::string arg2_str(jarg2);
53661   arg2 = &arg2_str;
53662   arg3 = (Dali::Property::Map *)jarg3;
53663   if (!arg3) {
53664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53665     return 0;
53666   }
53667   {
53668     try {
53669       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53670     } catch (std::out_of_range& e) {
53671       {
53672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53673       };
53674     } catch (std::exception& e) {
53675       {
53676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53677       };
53678     } catch (...) {
53679       {
53680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53681       };
53682     }
53683   }
53684   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53685
53686   //argout typemap for const std::string&
53687
53688   return jresult;
53689 }
53690
53691
53692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53693   void * jresult ;
53694   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53695   std::string *arg2 = 0 ;
53696   Dali::BaseHandle result;
53697
53698   arg1 = (Dali::Toolkit::Builder *)jarg1;
53699   if (!jarg2) {
53700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53701     return 0;
53702   }
53703   std::string arg2_str(jarg2);
53704   arg2 = &arg2_str;
53705   {
53706     try {
53707       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53708     } catch (std::out_of_range& e) {
53709       {
53710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53711       };
53712     } catch (std::exception& e) {
53713       {
53714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (...) {
53717       {
53718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53719       };
53720     }
53721   }
53722   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53723
53724   //argout typemap for const std::string&
53725
53726   return jresult;
53727 }
53728
53729
53730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53731   unsigned int jresult ;
53732   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53733   std::string *arg2 = 0 ;
53734   Dali::Handle *arg3 = 0 ;
53735   bool result;
53736
53737   arg1 = (Dali::Toolkit::Builder *)jarg1;
53738   if (!jarg2) {
53739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53740     return 0;
53741   }
53742   std::string arg2_str(jarg2);
53743   arg2 = &arg2_str;
53744   arg3 = (Dali::Handle *)jarg3;
53745   if (!arg3) {
53746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53747     return 0;
53748   }
53749   {
53750     try {
53751       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53763       };
53764     }
53765   }
53766   jresult = result;
53767
53768   //argout typemap for const std::string&
53769
53770   return jresult;
53771 }
53772
53773
53774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53775   unsigned int jresult ;
53776   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53777   Dali::Handle *arg2 = 0 ;
53778   std::string *arg3 = 0 ;
53779   bool result;
53780
53781   arg1 = (Dali::Toolkit::Builder *)jarg1;
53782   arg2 = (Dali::Handle *)jarg2;
53783   if (!arg2) {
53784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53785     return 0;
53786   }
53787   if (!jarg3) {
53788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53789     return 0;
53790   }
53791   std::string arg3_str(jarg3);
53792   arg3 = &arg3_str;
53793   {
53794     try {
53795       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53796     } catch (std::out_of_range& e) {
53797       {
53798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53799       };
53800     } catch (std::exception& e) {
53801       {
53802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53803       };
53804     } catch (...) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53807       };
53808     }
53809   }
53810   jresult = result;
53811
53812   //argout typemap for const std::string&
53813
53814   return jresult;
53815 }
53816
53817
53818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53819   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53820   Dali::Actor arg2 ;
53821   Dali::Actor *argp2 ;
53822
53823   arg1 = (Dali::Toolkit::Builder *)jarg1;
53824   argp2 = (Dali::Actor *)jarg2;
53825   if (!argp2) {
53826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53827     return ;
53828   }
53829   arg2 = *argp2;
53830   {
53831     try {
53832       (arg1)->AddActors(arg2);
53833     } catch (std::out_of_range& e) {
53834       {
53835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53836       };
53837     } catch (std::exception& e) {
53838       {
53839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53840       };
53841     } catch (...) {
53842       {
53843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53844       };
53845     }
53846   }
53847 }
53848
53849
53850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53851   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53852   std::string *arg2 = 0 ;
53853   Dali::Actor arg3 ;
53854   Dali::Actor *argp3 ;
53855
53856   arg1 = (Dali::Toolkit::Builder *)jarg1;
53857   if (!jarg2) {
53858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53859     return ;
53860   }
53861   std::string arg2_str(jarg2);
53862   arg2 = &arg2_str;
53863   argp3 = (Dali::Actor *)jarg3;
53864   if (!argp3) {
53865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53866     return ;
53867   }
53868   arg3 = *argp3;
53869   {
53870     try {
53871       (arg1)->AddActors((std::string const &)*arg2,arg3);
53872     } catch (std::out_of_range& e) {
53873       {
53874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53875       };
53876     } catch (std::exception& e) {
53877       {
53878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53879       };
53880     } catch (...) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53883       };
53884     }
53885   }
53886
53887   //argout typemap for const std::string&
53888
53889 }
53890
53891
53892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53893   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53894   std::string *arg2 = 0 ;
53895
53896   arg1 = (Dali::Toolkit::Builder *)jarg1;
53897   if (!jarg2) {
53898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53899     return ;
53900   }
53901   std::string arg2_str(jarg2);
53902   arg2 = &arg2_str;
53903   {
53904     try {
53905       (arg1)->CreateRenderTask((std::string const &)*arg2);
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53913       };
53914     } catch (...) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53917       };
53918     }
53919   }
53920
53921   //argout typemap for const std::string&
53922
53923 }
53924
53925
53926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53927   void * jresult ;
53928   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53929   std::string *arg2 = 0 ;
53930   Dali::FrameBufferImage result;
53931
53932   arg1 = (Dali::Toolkit::Builder *)jarg1;
53933   if (!jarg2) {
53934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53935     return 0;
53936   }
53937   std::string arg2_str(jarg2);
53938   arg2 = &arg2_str;
53939   {
53940     try {
53941       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53942     } catch (std::out_of_range& e) {
53943       {
53944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53945       };
53946     } catch (std::exception& e) {
53947       {
53948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53949       };
53950     } catch (...) {
53951       {
53952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53953       };
53954     }
53955   }
53956   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
53957
53958   //argout typemap for const std::string&
53959
53960   return jresult;
53961 }
53962
53963
53964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
53965   void * jresult ;
53966   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53967   std::string *arg2 = 0 ;
53968   Dali::Path result;
53969
53970   arg1 = (Dali::Toolkit::Builder *)jarg1;
53971   if (!jarg2) {
53972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53973     return 0;
53974   }
53975   std::string arg2_str(jarg2);
53976   arg2 = &arg2_str;
53977   {
53978     try {
53979       result = (arg1)->GetPath((std::string const &)*arg2);
53980     } catch (std::out_of_range& e) {
53981       {
53982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53983       };
53984     } catch (std::exception& e) {
53985       {
53986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53987       };
53988     } catch (...) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53991       };
53992     }
53993   }
53994   jresult = new Dali::Path((const Dali::Path &)result);
53995
53996   //argout typemap for const std::string&
53997
53998   return jresult;
53999 }
54000
54001
54002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54003   void * jresult ;
54004   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54005   std::string *arg2 = 0 ;
54006   Dali::PathConstrainer result;
54007
54008   arg1 = (Dali::Toolkit::Builder *)jarg1;
54009   if (!jarg2) {
54010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54011     return 0;
54012   }
54013   std::string arg2_str(jarg2);
54014   arg2 = &arg2_str;
54015   {
54016     try {
54017       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54018     } catch (std::out_of_range& e) {
54019       {
54020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54021       };
54022     } catch (std::exception& e) {
54023       {
54024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54025       };
54026     } catch (...) {
54027       {
54028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54029       };
54030     }
54031   }
54032   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54033
54034   //argout typemap for const std::string&
54035
54036   return jresult;
54037 }
54038
54039
54040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54041   void * jresult ;
54042   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54043   std::string *arg2 = 0 ;
54044   Dali::LinearConstrainer result;
54045
54046   arg1 = (Dali::Toolkit::Builder *)jarg1;
54047   if (!jarg2) {
54048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54049     return 0;
54050   }
54051   std::string arg2_str(jarg2);
54052   arg2 = &arg2_str;
54053   {
54054     try {
54055       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54056     } catch (std::out_of_range& e) {
54057       {
54058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54059       };
54060     } catch (std::exception& e) {
54061       {
54062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54063       };
54064     } catch (...) {
54065       {
54066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54067       };
54068     }
54069   }
54070   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54071
54072   //argout typemap for const std::string&
54073
54074   return jresult;
54075 }
54076
54077
54078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54079   void * jresult ;
54080   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54081   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54082
54083   arg1 = (Dali::Toolkit::Builder *)jarg1;
54084   {
54085     try {
54086       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54087     } catch (std::out_of_range& e) {
54088       {
54089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54090       };
54091     } catch (std::exception& e) {
54092       {
54093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54094       };
54095     } catch (...) {
54096       {
54097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54098       };
54099     }
54100   }
54101   jresult = (void *)result;
54102   return jresult;
54103 }
54104
54105
54106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54107   void * jresult ;
54108   Dali::Toolkit::TransitionData *result = 0 ;
54109
54110   {
54111     try {
54112       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54113     } catch (std::out_of_range& e) {
54114       {
54115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54116       };
54117     } catch (std::exception& e) {
54118       {
54119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54120       };
54121     } catch (...) {
54122       {
54123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54124       };
54125     }
54126   }
54127   jresult = (void *)result;
54128   return jresult;
54129 }
54130
54131
54132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54133   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54134
54135   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54136   {
54137     try {
54138       delete arg1;
54139     } catch (std::out_of_range& e) {
54140       {
54141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54142       };
54143     } catch (std::exception& e) {
54144       {
54145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54146       };
54147     } catch (...) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54150       };
54151     }
54152   }
54153 }
54154
54155
54156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54157   void * jresult ;
54158   Dali::Property::Map *arg1 = 0 ;
54159   Dali::Toolkit::TransitionData result;
54160
54161   arg1 = (Dali::Property::Map *)jarg1;
54162   if (!arg1) {
54163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54164     return 0;
54165   }
54166   {
54167     try {
54168       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54169     } catch (std::out_of_range& e) {
54170       {
54171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54172       };
54173     } catch (std::exception& e) {
54174       {
54175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54176       };
54177     } catch (...) {
54178       {
54179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54180       };
54181     }
54182   }
54183   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54184   return jresult;
54185 }
54186
54187
54188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54189   void * jresult ;
54190   Dali::Property::Array *arg1 = 0 ;
54191   Dali::Toolkit::TransitionData result;
54192
54193   arg1 = (Dali::Property::Array *)jarg1;
54194   if (!arg1) {
54195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54196     return 0;
54197   }
54198   {
54199     try {
54200       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54201     } catch (std::out_of_range& e) {
54202       {
54203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54204       };
54205     } catch (std::exception& e) {
54206       {
54207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54208       };
54209     } catch (...) {
54210       {
54211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54212       };
54213     }
54214   }
54215   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54216   return jresult;
54217 }
54218
54219
54220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54221   void * jresult ;
54222   Dali::BaseHandle arg1 ;
54223   Dali::BaseHandle *argp1 ;
54224   Dali::Toolkit::TransitionData result;
54225
54226   argp1 = (Dali::BaseHandle *)jarg1;
54227   if (!argp1) {
54228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54229     return 0;
54230   }
54231   arg1 = *argp1;
54232   {
54233     try {
54234       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54235     } catch (std::out_of_range& e) {
54236       {
54237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54238       };
54239     } catch (std::exception& e) {
54240       {
54241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54242       };
54243     } catch (...) {
54244       {
54245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54246       };
54247     }
54248   }
54249   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54250   return jresult;
54251 }
54252
54253
54254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54255   void * jresult ;
54256   Dali::Toolkit::TransitionData *arg1 = 0 ;
54257   Dali::Toolkit::TransitionData *result = 0 ;
54258
54259   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54260   if (!arg1) {
54261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54262     return 0;
54263   }
54264   {
54265     try {
54266       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54267     } catch (std::out_of_range& e) {
54268       {
54269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54270       };
54271     } catch (std::exception& e) {
54272       {
54273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54274       };
54275     } catch (...) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54278       };
54279     }
54280   }
54281   jresult = (void *)result;
54282   return jresult;
54283 }
54284
54285
54286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54287   void * jresult ;
54288   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54289   Dali::Toolkit::TransitionData *arg2 = 0 ;
54290   Dali::Toolkit::TransitionData *result = 0 ;
54291
54292   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54293   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54294   if (!arg2) {
54295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54296     return 0;
54297   }
54298   {
54299     try {
54300       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54301     } catch (std::out_of_range& e) {
54302       {
54303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54304       };
54305     } catch (std::exception& e) {
54306       {
54307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54308       };
54309     } catch (...) {
54310       {
54311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54312       };
54313     }
54314   }
54315   jresult = (void *)result;
54316   return jresult;
54317 }
54318
54319
54320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54321   unsigned long jresult ;
54322   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54323   size_t result;
54324
54325   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54326   {
54327     try {
54328       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54329     } catch (std::out_of_range& e) {
54330       {
54331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54332       };
54333     } catch (std::exception& e) {
54334       {
54335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54336       };
54337     } catch (...) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54340       };
54341     }
54342   }
54343   jresult = (unsigned long)result;
54344   return jresult;
54345 }
54346
54347
54348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54349   void * jresult ;
54350   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54351   size_t arg2 ;
54352   Dali::Property::Map result;
54353
54354   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54355   arg2 = (size_t)jarg2;
54356   {
54357     try {
54358       result = (arg1)->GetAnimatorAt(arg2);
54359     } catch (std::out_of_range& e) {
54360       {
54361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54362       };
54363     } catch (std::exception& e) {
54364       {
54365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54366       };
54367     } catch (...) {
54368       {
54369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54370       };
54371     }
54372   }
54373   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54374   return jresult;
54375 }
54376
54377
54378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54379   void * jresult ;
54380   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54381   Dali::Toolkit::TransitionData *result = 0 ;
54382
54383   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54384   {
54385     try {
54386       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54387     } catch (std::out_of_range& e) {
54388       {
54389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54390       };
54391     } catch (std::exception& e) {
54392       {
54393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54398       };
54399     }
54400   }
54401   jresult = (void *)result;
54402   return jresult;
54403 }
54404
54405
54406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54407   int jresult ;
54408   int result;
54409
54410   {
54411     try {
54412       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54413     } catch (std::out_of_range& e) {
54414       {
54415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54416       };
54417     } catch (std::exception& e) {
54418       {
54419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54420       };
54421     } catch (...) {
54422       {
54423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54424       };
54425     }
54426   }
54427   jresult = (int)result;
54428   return jresult;
54429 }
54430
54431
54432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54433   int jresult ;
54434   int result;
54435
54436   {
54437     try {
54438       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54439     } catch (std::out_of_range& e) {
54440       {
54441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54442       };
54443     } catch (std::exception& e) {
54444       {
54445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54446       };
54447     } catch (...) {
54448       {
54449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54450       };
54451     }
54452   }
54453   jresult = (int)result;
54454   return jresult;
54455 }
54456
54457
54458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54459   int jresult ;
54460   int result;
54461
54462   {
54463     try {
54464       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54465     } catch (std::out_of_range& e) {
54466       {
54467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54468       };
54469     } catch (std::exception& e) {
54470       {
54471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54472       };
54473     } catch (...) {
54474       {
54475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54476       };
54477     }
54478   }
54479   jresult = (int)result;
54480   return jresult;
54481 }
54482
54483
54484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54485   int jresult ;
54486   int result;
54487
54488   {
54489     try {
54490       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54491     } catch (std::out_of_range& e) {
54492       {
54493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54494       };
54495     } catch (std::exception& e) {
54496       {
54497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54498       };
54499     } catch (...) {
54500       {
54501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54502       };
54503     }
54504   }
54505   jresult = (int)result;
54506   return jresult;
54507 }
54508
54509
54510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54511   int jresult ;
54512   int result;
54513
54514   {
54515     try {
54516       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54528       };
54529     }
54530   }
54531   jresult = (int)result;
54532   return jresult;
54533 }
54534
54535
54536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54537   int jresult ;
54538   int result;
54539
54540   {
54541     try {
54542       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54543     } catch (std::out_of_range& e) {
54544       {
54545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54546       };
54547     } catch (std::exception& e) {
54548       {
54549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54550       };
54551     } catch (...) {
54552       {
54553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54554       };
54555     }
54556   }
54557   jresult = (int)result;
54558   return jresult;
54559 }
54560
54561
54562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54563   int jresult ;
54564   int result;
54565
54566   {
54567     try {
54568       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54569     } catch (std::out_of_range& e) {
54570       {
54571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (std::exception& e) {
54574       {
54575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54576       };
54577     } catch (...) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54580       };
54581     }
54582   }
54583   jresult = (int)result;
54584   return jresult;
54585 }
54586
54587
54588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54589   int jresult ;
54590   int result;
54591
54592   {
54593     try {
54594       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54595     } catch (std::out_of_range& e) {
54596       {
54597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54598       };
54599     } catch (std::exception& e) {
54600       {
54601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54602       };
54603     } catch (...) {
54604       {
54605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54606       };
54607     }
54608   }
54609   jresult = (int)result;
54610   return jresult;
54611 }
54612
54613
54614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54615   int jresult ;
54616   int result;
54617
54618   {
54619     try {
54620       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54621     } catch (std::out_of_range& e) {
54622       {
54623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54624       };
54625     } catch (std::exception& e) {
54626       {
54627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54628       };
54629     } catch (...) {
54630       {
54631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54632       };
54633     }
54634   }
54635   jresult = (int)result;
54636   return jresult;
54637 }
54638
54639
54640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54641   int jresult ;
54642   int result;
54643
54644   {
54645     try {
54646       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54647     } catch (std::out_of_range& e) {
54648       {
54649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54650       };
54651     } catch (std::exception& e) {
54652       {
54653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54654       };
54655     } catch (...) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54658       };
54659     }
54660   }
54661   jresult = (int)result;
54662   return jresult;
54663 }
54664
54665
54666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54667   int jresult ;
54668   int result;
54669
54670   {
54671     try {
54672       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54673     } catch (std::out_of_range& e) {
54674       {
54675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54676       };
54677     } catch (std::exception& e) {
54678       {
54679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54680       };
54681     } catch (...) {
54682       {
54683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54684       };
54685     }
54686   }
54687   jresult = (int)result;
54688   return jresult;
54689 }
54690
54691
54692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54693   int jresult ;
54694   int result;
54695
54696   {
54697     try {
54698       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54699     } catch (std::out_of_range& e) {
54700       {
54701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54702       };
54703     } catch (std::exception& e) {
54704       {
54705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54706       };
54707     } catch (...) {
54708       {
54709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54710       };
54711     }
54712   }
54713   jresult = (int)result;
54714   return jresult;
54715 }
54716
54717
54718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54719   int jresult ;
54720   int result;
54721
54722   {
54723     try {
54724       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54725     } catch (std::out_of_range& e) {
54726       {
54727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54728       };
54729     } catch (std::exception& e) {
54730       {
54731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54736       };
54737     }
54738   }
54739   jresult = (int)result;
54740   return jresult;
54741 }
54742
54743
54744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54745   int jresult ;
54746   int result;
54747
54748   {
54749     try {
54750       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54751     } catch (std::out_of_range& e) {
54752       {
54753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (std::exception& e) {
54756       {
54757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (...) {
54760       {
54761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54762       };
54763     }
54764   }
54765   jresult = (int)result;
54766   return jresult;
54767 }
54768
54769
54770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54771   void * jresult ;
54772   Dali::Toolkit::Control result;
54773
54774   {
54775     try {
54776       result = Dali::Toolkit::Internal::Control::New();
54777     } catch (std::out_of_range& e) {
54778       {
54779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54780       };
54781     } catch (std::exception& e) {
54782       {
54783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54784       };
54785     } catch (...) {
54786       {
54787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54788       };
54789     }
54790   }
54791   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54792   return jresult;
54793 }
54794
54795
54796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54798   std::string *arg2 = 0 ;
54799
54800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54801   if (!jarg2) {
54802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54803     return ;
54804   }
54805   std::string arg2_str(jarg2);
54806   arg2 = &arg2_str;
54807   {
54808     try {
54809       (arg1)->SetStyleName((std::string const &)*arg2);
54810     } catch (std::out_of_range& e) {
54811       {
54812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54813       };
54814     } catch (std::exception& e) {
54815       {
54816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54817       };
54818     } catch (...) {
54819       {
54820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54821       };
54822     }
54823   }
54824
54825   //argout typemap for const std::string&
54826
54827 }
54828
54829
54830 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54831   char * jresult ;
54832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54833   std::string *result = 0 ;
54834
54835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54836   {
54837     try {
54838       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
54839     } catch (std::out_of_range& e) {
54840       {
54841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54842       };
54843     } catch (std::exception& e) {
54844       {
54845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54850       };
54851     }
54852   }
54853   jresult = SWIG_csharp_string_callback(result->c_str());
54854   return jresult;
54855 }
54856
54857
54858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54860   Dali::Vector4 *arg2 = 0 ;
54861
54862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54863   arg2 = (Dali::Vector4 *)jarg2;
54864   if (!arg2) {
54865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54866     return ;
54867   }
54868   {
54869     try {
54870       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54871     } catch (std::out_of_range& e) {
54872       {
54873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54874       };
54875     } catch (std::exception& e) {
54876       {
54877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54878       };
54879     } catch (...) {
54880       {
54881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54882       };
54883     }
54884   }
54885 }
54886
54887
54888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54889   void * jresult ;
54890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54891   Dali::Vector4 result;
54892
54893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54894   {
54895     try {
54896       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54897     } catch (std::out_of_range& e) {
54898       {
54899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54900       };
54901     } catch (std::exception& e) {
54902       {
54903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54904       };
54905     } catch (...) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54908       };
54909     }
54910   }
54911   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54912   return jresult;
54913 }
54914
54915
54916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54918   Dali::Image arg2 ;
54919   Dali::Image *argp2 ;
54920
54921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54922   argp2 = (Dali::Image *)jarg2;
54923   if (!argp2) {
54924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54925     return ;
54926   }
54927   arg2 = *argp2;
54928   {
54929     try {
54930       (arg1)->SetBackgroundImage(arg2);
54931     } catch (std::out_of_range& e) {
54932       {
54933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54934       };
54935     } catch (std::exception& e) {
54936       {
54937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54938       };
54939     } catch (...) {
54940       {
54941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54942       };
54943     }
54944   }
54945 }
54946
54947
54948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54950   Dali::Property::Map *arg2 = 0 ;
54951
54952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54953   arg2 = (Dali::Property::Map *)jarg2;
54954   if (!arg2) {
54955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54956     return ;
54957   }
54958   {
54959     try {
54960       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
54961     } catch (std::out_of_range& e) {
54962       {
54963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54964       };
54965     } catch (std::exception& e) {
54966       {
54967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54968       };
54969     } catch (...) {
54970       {
54971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54972       };
54973     }
54974   }
54975 }
54976
54977
54978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
54979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54980
54981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54982   {
54983     try {
54984       (arg1)->ClearBackground();
54985     } catch (std::out_of_range& e) {
54986       {
54987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54988       };
54989     } catch (std::exception& e) {
54990       {
54991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54996       };
54997     }
54998   }
54999 }
55000
55001
55002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55004   Dali::Gesture::Type arg2 ;
55005
55006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55007   arg2 = (Dali::Gesture::Type)jarg2;
55008   {
55009     try {
55010       (arg1)->EnableGestureDetection(arg2);
55011     } catch (std::out_of_range& e) {
55012       {
55013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55014       };
55015     } catch (std::exception& e) {
55016       {
55017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55018       };
55019     } catch (...) {
55020       {
55021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55022       };
55023     }
55024   }
55025 }
55026
55027
55028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55030   Dali::Gesture::Type arg2 ;
55031
55032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55033   arg2 = (Dali::Gesture::Type)jarg2;
55034   {
55035     try {
55036       (arg1)->DisableGestureDetection(arg2);
55037     } catch (std::out_of_range& e) {
55038       {
55039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55040       };
55041     } catch (std::exception& e) {
55042       {
55043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55044       };
55045     } catch (...) {
55046       {
55047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55048       };
55049     }
55050   }
55051 }
55052
55053
55054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55055   void * jresult ;
55056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55057   Dali::PinchGestureDetector result;
55058
55059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55060   {
55061     try {
55062       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55063     } catch (std::out_of_range& e) {
55064       {
55065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55066       };
55067     } catch (std::exception& e) {
55068       {
55069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55070       };
55071     } catch (...) {
55072       {
55073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55074       };
55075     }
55076   }
55077   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55078   return jresult;
55079 }
55080
55081
55082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55083   void * jresult ;
55084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55085   Dali::PanGestureDetector result;
55086
55087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55088   {
55089     try {
55090       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55091     } catch (std::out_of_range& e) {
55092       {
55093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55094       };
55095     } catch (std::exception& e) {
55096       {
55097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55098       };
55099     } catch (...) {
55100       {
55101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55102       };
55103     }
55104   }
55105   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55106   return jresult;
55107 }
55108
55109
55110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55111   void * jresult ;
55112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55113   Dali::TapGestureDetector result;
55114
55115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55116   {
55117     try {
55118       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55119     } catch (std::out_of_range& e) {
55120       {
55121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55122       };
55123     } catch (std::exception& e) {
55124       {
55125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55126       };
55127     } catch (...) {
55128       {
55129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55130       };
55131     }
55132   }
55133   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55134   return jresult;
55135 }
55136
55137
55138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55139   void * jresult ;
55140   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55141   Dali::LongPressGestureDetector result;
55142
55143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55144   {
55145     try {
55146       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55147     } catch (std::out_of_range& e) {
55148       {
55149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (std::exception& e) {
55152       {
55153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55158       };
55159     }
55160   }
55161   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55162   return jresult;
55163 }
55164
55165
55166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55168   bool arg2 ;
55169
55170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55171   arg2 = jarg2 ? true : false;
55172   {
55173     try {
55174       (arg1)->SetKeyboardNavigationSupport(arg2);
55175     } catch (std::out_of_range& e) {
55176       {
55177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55178       };
55179     } catch (std::exception& e) {
55180       {
55181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55182       };
55183     } catch (...) {
55184       {
55185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55186       };
55187     }
55188   }
55189 }
55190
55191
55192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55193   unsigned int jresult ;
55194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55195   bool result;
55196
55197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55198   {
55199     try {
55200       result = (bool)(arg1)->IsKeyboardNavigationSupported();
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 = result;
55216   return jresult;
55217 }
55218
55219
55220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55222
55223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55224   {
55225     try {
55226       (arg1)->SetKeyInputFocus();
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55238       };
55239     }
55240   }
55241 }
55242
55243
55244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55245   unsigned int jresult ;
55246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55247   bool result;
55248
55249   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55250   {
55251     try {
55252       result = (bool)(arg1)->HasKeyInputFocus();
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 = result;
55268   return jresult;
55269 }
55270
55271
55272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55274
55275   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55276   {
55277     try {
55278       (arg1)->ClearKeyInputFocus();
55279     } catch (std::out_of_range& e) {
55280       {
55281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55282       };
55283     } catch (std::exception& e) {
55284       {
55285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55290       };
55291     }
55292   }
55293 }
55294
55295
55296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55298   bool arg2 ;
55299
55300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55301   arg2 = jarg2 ? true : false;
55302   {
55303     try {
55304       (arg1)->SetAsKeyboardFocusGroup(arg2);
55305     } catch (std::out_of_range& e) {
55306       {
55307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55308       };
55309     } catch (std::exception& e) {
55310       {
55311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55316       };
55317     }
55318   }
55319 }
55320
55321
55322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55323   unsigned int jresult ;
55324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55325   bool result;
55326
55327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55328   {
55329     try {
55330       result = (bool)(arg1)->IsKeyboardFocusGroup();
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 = result;
55346   return jresult;
55347 }
55348
55349
55350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55352
55353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55354   {
55355     try {
55356       (arg1)->AccessibilityActivate();
55357     } catch (std::out_of_range& e) {
55358       {
55359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55360       };
55361     } catch (std::exception& e) {
55362       {
55363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55364       };
55365     } catch (...) {
55366       {
55367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55368       };
55369     }
55370   }
55371 }
55372
55373
55374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55376
55377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55378   {
55379     try {
55380       (arg1)->KeyboardEnter();
55381     } catch (std::out_of_range& e) {
55382       {
55383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55384       };
55385     } catch (std::exception& e) {
55386       {
55387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55388       };
55389     } catch (...) {
55390       {
55391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55392       };
55393     }
55394   }
55395 }
55396
55397
55398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55399   void * jresult ;
55400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55401   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55402
55403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55404   {
55405     try {
55406       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55407     } catch (std::out_of_range& e) {
55408       {
55409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55410       };
55411     } catch (std::exception& e) {
55412       {
55413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55414       };
55415     } catch (...) {
55416       {
55417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55418       };
55419     }
55420   }
55421   jresult = (void *)result;
55422   return jresult;
55423 }
55424
55425
55426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55427   void * jresult ;
55428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55429   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55430
55431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55432   {
55433     try {
55434       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
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 = (void *)result;
55450   return jresult;
55451 }
55452
55453
55454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55455   void * jresult ;
55456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55457   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55458
55459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55460   {
55461     try {
55462       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55463     } catch (std::out_of_range& e) {
55464       {
55465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (std::exception& e) {
55468       {
55469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55470       };
55471     } catch (...) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55474       };
55475     }
55476   }
55477   jresult = (void *)result;
55478   return jresult;
55479 }
55480
55481
55482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55483   unsigned int jresult ;
55484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55485   Dali::KeyEvent *arg2 = 0 ;
55486   bool result;
55487
55488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55489   arg2 = (Dali::KeyEvent *)jarg2;
55490   if (!arg2) {
55491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55492     return 0;
55493   }
55494   {
55495     try {
55496       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55497     } catch (std::out_of_range& e) {
55498       {
55499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55500       };
55501     } catch (std::exception& e) {
55502       {
55503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55504       };
55505     } catch (...) {
55506       {
55507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55508       };
55509     }
55510   }
55511   jresult = result;
55512   return jresult;
55513 }
55514
55515
55516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55518   int arg2 ;
55519   SwigDirector_ViewImpl *darg = 0;
55520
55521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55522   arg2 = (int)jarg2;
55523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55524   {
55525     try {
55526       (darg)->OnStageConnection(arg2);
55527     } catch (std::out_of_range& e) {
55528       {
55529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55530       };
55531     } catch (std::exception& e) {
55532       {
55533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55534       };
55535     } catch (...) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55538       };
55539     }
55540   }
55541 }
55542
55543
55544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55546   int arg2 ;
55547   SwigDirector_ViewImpl *darg = 0;
55548
55549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55550   arg2 = (int)jarg2;
55551   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55552   {
55553     try {
55554       (darg)->OnStageConnectionSwigPublic(arg2);
55555     } catch (std::out_of_range& e) {
55556       {
55557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55558       };
55559     } catch (std::exception& e) {
55560       {
55561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55562       };
55563     } catch (...) {
55564       {
55565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55566       };
55567     }
55568   }
55569 }
55570
55571
55572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55574   SwigDirector_ViewImpl *darg = 0;
55575
55576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55577   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55578   {
55579     try {
55580       (darg)->OnStageDisconnection();
55581     } catch (std::out_of_range& e) {
55582       {
55583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55584       };
55585     } catch (std::exception& e) {
55586       {
55587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55588       };
55589     } catch (...) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55592       };
55593     }
55594   }
55595 }
55596
55597
55598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55600   SwigDirector_ViewImpl *darg = 0;
55601
55602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55603   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55604   {
55605     try {
55606       (darg)->OnStageDisconnectionSwigPublic();
55607     } catch (std::out_of_range& e) {
55608       {
55609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55610       };
55611     } catch (std::exception& e) {
55612       {
55613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55618       };
55619     }
55620   }
55621 }
55622
55623
55624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55626   Dali::Actor *arg2 = 0 ;
55627   SwigDirector_ViewImpl *darg = 0;
55628
55629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55630   arg2 = (Dali::Actor *)jarg2;
55631   if (!arg2) {
55632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55633     return ;
55634   }
55635   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55636   {
55637     try {
55638       (darg)->OnChildAdd(*arg2);
55639     } catch (std::out_of_range& e) {
55640       {
55641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55642       };
55643     } catch (std::exception& e) {
55644       {
55645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55646       };
55647     } catch (...) {
55648       {
55649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55650       };
55651     }
55652   }
55653 }
55654
55655
55656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55657   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55658   Dali::Actor *arg2 = 0 ;
55659   SwigDirector_ViewImpl *darg = 0;
55660
55661   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55662   arg2 = (Dali::Actor *)jarg2;
55663   if (!arg2) {
55664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55665     return ;
55666   }
55667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55668   {
55669     try {
55670       (darg)->OnChildAddSwigPublic(*arg2);
55671     } catch (std::out_of_range& e) {
55672       {
55673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55674       };
55675     } catch (std::exception& e) {
55676       {
55677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55678       };
55679     } catch (...) {
55680       {
55681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55682       };
55683     }
55684   }
55685 }
55686
55687
55688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55690   Dali::Actor *arg2 = 0 ;
55691   SwigDirector_ViewImpl *darg = 0;
55692
55693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55694   arg2 = (Dali::Actor *)jarg2;
55695   if (!arg2) {
55696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55697     return ;
55698   }
55699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55700   {
55701     try {
55702       (darg)->OnChildRemove(*arg2);
55703     } catch (std::out_of_range& e) {
55704       {
55705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55706       };
55707     } catch (std::exception& e) {
55708       {
55709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55710       };
55711     } catch (...) {
55712       {
55713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55714       };
55715     }
55716   }
55717 }
55718
55719
55720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55722   Dali::Actor *arg2 = 0 ;
55723   SwigDirector_ViewImpl *darg = 0;
55724
55725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55726   arg2 = (Dali::Actor *)jarg2;
55727   if (!arg2) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55729     return ;
55730   }
55731   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55732   {
55733     try {
55734       (darg)->OnChildRemoveSwigPublic(*arg2);
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55742       };
55743     } catch (...) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55746       };
55747     }
55748   }
55749 }
55750
55751
55752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55754   Dali::Property::Index arg2 ;
55755   Dali::Property::Value arg3 ;
55756   Dali::Property::Value *argp3 ;
55757   SwigDirector_ViewImpl *darg = 0;
55758
55759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55760   arg2 = (Dali::Property::Index)jarg2;
55761   argp3 = (Dali::Property::Value *)jarg3;
55762   if (!argp3) {
55763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55764     return ;
55765   }
55766   arg3 = *argp3;
55767   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55768   {
55769     try {
55770       (darg)->OnPropertySet(arg2,arg3);
55771     } catch (std::out_of_range& e) {
55772       {
55773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (std::exception& e) {
55776       {
55777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55778       };
55779     } catch (...) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55782       };
55783     }
55784   }
55785 }
55786
55787
55788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55790   Dali::Property::Index arg2 ;
55791   Dali::Property::Value arg3 ;
55792   Dali::Property::Value *argp3 ;
55793   SwigDirector_ViewImpl *darg = 0;
55794
55795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55796   arg2 = (Dali::Property::Index)jarg2;
55797   argp3 = (Dali::Property::Value *)jarg3;
55798   if (!argp3) {
55799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55800     return ;
55801   }
55802   arg3 = *argp3;
55803   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55804   {
55805     try {
55806       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55807     } catch (std::out_of_range& e) {
55808       {
55809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55810       };
55811     } catch (std::exception& e) {
55812       {
55813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55814       };
55815     } catch (...) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55818       };
55819     }
55820   }
55821 }
55822
55823
55824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55826   Dali::Vector3 *arg2 = 0 ;
55827   SwigDirector_ViewImpl *darg = 0;
55828
55829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55830   arg2 = (Dali::Vector3 *)jarg2;
55831   if (!arg2) {
55832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55833     return ;
55834   }
55835   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55836   {
55837     try {
55838       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55839     } catch (std::out_of_range& e) {
55840       {
55841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55842       };
55843     } catch (std::exception& e) {
55844       {
55845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55846       };
55847     } catch (...) {
55848       {
55849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55850       };
55851     }
55852   }
55853 }
55854
55855
55856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55858   Dali::Vector3 *arg2 = 0 ;
55859   SwigDirector_ViewImpl *darg = 0;
55860
55861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55862   arg2 = (Dali::Vector3 *)jarg2;
55863   if (!arg2) {
55864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55865     return ;
55866   }
55867   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55868   {
55869     try {
55870       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55871     } catch (std::out_of_range& e) {
55872       {
55873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55874       };
55875     } catch (std::exception& e) {
55876       {
55877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55878       };
55879     } catch (...) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55882       };
55883     }
55884   }
55885 }
55886
55887
55888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55890   Dali::Animation *arg2 = 0 ;
55891   Dali::Vector3 *arg3 = 0 ;
55892   SwigDirector_ViewImpl *darg = 0;
55893
55894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55895   arg2 = (Dali::Animation *)jarg2;
55896   if (!arg2) {
55897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55898     return ;
55899   }
55900   arg3 = (Dali::Vector3 *)jarg3;
55901   if (!arg3) {
55902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55903     return ;
55904   }
55905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55906   {
55907     try {
55908       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55909     } catch (std::out_of_range& e) {
55910       {
55911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55912       };
55913     } catch (std::exception& e) {
55914       {
55915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55916       };
55917     } catch (...) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55920       };
55921     }
55922   }
55923 }
55924
55925
55926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55928   Dali::Animation *arg2 = 0 ;
55929   Dali::Vector3 *arg3 = 0 ;
55930   SwigDirector_ViewImpl *darg = 0;
55931
55932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55933   arg2 = (Dali::Animation *)jarg2;
55934   if (!arg2) {
55935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55936     return ;
55937   }
55938   arg3 = (Dali::Vector3 *)jarg3;
55939   if (!arg3) {
55940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55941     return ;
55942   }
55943   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55944   {
55945     try {
55946       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55947     } catch (std::out_of_range& e) {
55948       {
55949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55950       };
55951     } catch (std::exception& e) {
55952       {
55953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55954       };
55955     } catch (...) {
55956       {
55957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55958       };
55959     }
55960   }
55961 }
55962
55963
55964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
55965   unsigned int jresult ;
55966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55967   Dali::TouchEvent *arg2 = 0 ;
55968   SwigDirector_ViewImpl *darg = 0;
55969   bool result;
55970
55971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55972   arg2 = (Dali::TouchEvent *)jarg2;
55973   if (!arg2) {
55974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
55975     return 0;
55976   }
55977   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55978   {
55979     try {
55980       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
55981     } catch (std::out_of_range& e) {
55982       {
55983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55984       };
55985     } catch (std::exception& e) {
55986       {
55987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55988       };
55989     } catch (...) {
55990       {
55991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55992       };
55993     }
55994   }
55995   jresult = result;
55996   return jresult;
55997 }
55998
55999
56000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56001   unsigned int jresult ;
56002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56003   Dali::TouchEvent *arg2 = 0 ;
56004   SwigDirector_ViewImpl *darg = 0;
56005   bool result;
56006
56007   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56008   arg2 = (Dali::TouchEvent *)jarg2;
56009   if (!arg2) {
56010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56011     return 0;
56012   }
56013   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56014   {
56015     try {
56016       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56017     } catch (std::out_of_range& e) {
56018       {
56019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (std::exception& e) {
56022       {
56023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56028       };
56029     }
56030   }
56031   jresult = result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56037   unsigned int jresult ;
56038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56039   Dali::HoverEvent *arg2 = 0 ;
56040   SwigDirector_ViewImpl *darg = 0;
56041   bool result;
56042
56043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56044   arg2 = (Dali::HoverEvent *)jarg2;
56045   if (!arg2) {
56046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56047     return 0;
56048   }
56049   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56050   {
56051     try {
56052       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56053     } catch (std::out_of_range& e) {
56054       {
56055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (std::exception& e) {
56058       {
56059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56060       };
56061     } catch (...) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56064       };
56065     }
56066   }
56067   jresult = result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56073   unsigned int jresult ;
56074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56075   Dali::HoverEvent *arg2 = 0 ;
56076   SwigDirector_ViewImpl *darg = 0;
56077   bool result;
56078
56079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56080   arg2 = (Dali::HoverEvent *)jarg2;
56081   if (!arg2) {
56082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56083     return 0;
56084   }
56085   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56086   {
56087     try {
56088       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56089     } catch (std::out_of_range& e) {
56090       {
56091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56092       };
56093     } catch (std::exception& e) {
56094       {
56095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56096       };
56097     } catch (...) {
56098       {
56099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56100       };
56101     }
56102   }
56103   jresult = result;
56104   return jresult;
56105 }
56106
56107
56108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56109   unsigned int jresult ;
56110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56111   Dali::KeyEvent *arg2 = 0 ;
56112   SwigDirector_ViewImpl *darg = 0;
56113   bool result;
56114
56115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56116   arg2 = (Dali::KeyEvent *)jarg2;
56117   if (!arg2) {
56118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56119     return 0;
56120   }
56121   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56122   {
56123     try {
56124       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56125     } catch (std::out_of_range& e) {
56126       {
56127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56128       };
56129     } catch (std::exception& e) {
56130       {
56131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56132       };
56133     } catch (...) {
56134       {
56135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56136       };
56137     }
56138   }
56139   jresult = result;
56140   return jresult;
56141 }
56142
56143
56144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56145   unsigned int jresult ;
56146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56147   Dali::KeyEvent *arg2 = 0 ;
56148   SwigDirector_ViewImpl *darg = 0;
56149   bool result;
56150
56151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56152   arg2 = (Dali::KeyEvent *)jarg2;
56153   if (!arg2) {
56154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56155     return 0;
56156   }
56157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56158   {
56159     try {
56160       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56161     } catch (std::out_of_range& e) {
56162       {
56163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56164       };
56165     } catch (std::exception& e) {
56166       {
56167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56168       };
56169     } catch (...) {
56170       {
56171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56172       };
56173     }
56174   }
56175   jresult = result;
56176   return jresult;
56177 }
56178
56179
56180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56181   unsigned int jresult ;
56182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56183   Dali::WheelEvent *arg2 = 0 ;
56184   SwigDirector_ViewImpl *darg = 0;
56185   bool result;
56186
56187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56188   arg2 = (Dali::WheelEvent *)jarg2;
56189   if (!arg2) {
56190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56191     return 0;
56192   }
56193   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56194   {
56195     try {
56196       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56197     } catch (std::out_of_range& e) {
56198       {
56199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (std::exception& e) {
56202       {
56203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (...) {
56206       {
56207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56208       };
56209     }
56210   }
56211   jresult = result;
56212   return jresult;
56213 }
56214
56215
56216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56217   unsigned int jresult ;
56218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56219   Dali::WheelEvent *arg2 = 0 ;
56220   SwigDirector_ViewImpl *darg = 0;
56221   bool result;
56222
56223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56224   arg2 = (Dali::WheelEvent *)jarg2;
56225   if (!arg2) {
56226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56227     return 0;
56228   }
56229   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56230   {
56231     try {
56232       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56233     } catch (std::out_of_range& e) {
56234       {
56235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56236       };
56237     } catch (std::exception& e) {
56238       {
56239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (...) {
56242       {
56243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56244       };
56245     }
56246   }
56247   jresult = result;
56248   return jresult;
56249 }
56250
56251
56252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56254   Dali::Vector2 *arg2 = 0 ;
56255   Dali::RelayoutContainer *arg3 = 0 ;
56256   SwigDirector_ViewImpl *darg = 0;
56257
56258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56259   arg2 = (Dali::Vector2 *)jarg2;
56260   if (!arg2) {
56261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56262     return ;
56263   }
56264   arg3 = (Dali::RelayoutContainer *)jarg3;
56265   if (!arg3) {
56266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56267     return ;
56268   }
56269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56270   {
56271     try {
56272       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56273     } catch (std::out_of_range& e) {
56274       {
56275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56276       };
56277     } catch (std::exception& e) {
56278       {
56279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56280       };
56281     } catch (...) {
56282       {
56283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56284       };
56285     }
56286   }
56287 }
56288
56289
56290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56292   Dali::Vector2 *arg2 = 0 ;
56293   Dali::RelayoutContainer *arg3 = 0 ;
56294   SwigDirector_ViewImpl *darg = 0;
56295
56296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56297   arg2 = (Dali::Vector2 *)jarg2;
56298   if (!arg2) {
56299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56300     return ;
56301   }
56302   arg3 = (Dali::RelayoutContainer *)jarg3;
56303   if (!arg3) {
56304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56305     return ;
56306   }
56307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56308   {
56309     try {
56310       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56311     } catch (std::out_of_range& e) {
56312       {
56313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56314       };
56315     } catch (std::exception& e) {
56316       {
56317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56318       };
56319     } catch (...) {
56320       {
56321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56322       };
56323     }
56324   }
56325 }
56326
56327
56328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56330   Dali::ResizePolicy::Type arg2 ;
56331   Dali::Dimension::Type arg3 ;
56332   SwigDirector_ViewImpl *darg = 0;
56333
56334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56335   arg2 = (Dali::ResizePolicy::Type)jarg2;
56336   arg3 = (Dali::Dimension::Type)jarg3;
56337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56338   {
56339     try {
56340       (darg)->OnSetResizePolicy(arg2,arg3);
56341     } catch (std::out_of_range& e) {
56342       {
56343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56344       };
56345     } catch (std::exception& e) {
56346       {
56347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56352       };
56353     }
56354   }
56355 }
56356
56357
56358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56360   Dali::ResizePolicy::Type arg2 ;
56361   Dali::Dimension::Type arg3 ;
56362   SwigDirector_ViewImpl *darg = 0;
56363
56364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56365   arg2 = (Dali::ResizePolicy::Type)jarg2;
56366   arg3 = (Dali::Dimension::Type)jarg3;
56367   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56368   {
56369     try {
56370       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56371     } catch (std::out_of_range& e) {
56372       {
56373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56374       };
56375     } catch (std::exception& e) {
56376       {
56377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56378       };
56379     } catch (...) {
56380       {
56381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56382       };
56383     }
56384   }
56385 }
56386
56387
56388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56389   void * jresult ;
56390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56391   SwigDirector_ViewImpl *darg = 0;
56392   Dali::Vector3 result;
56393
56394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56395   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56396   {
56397     try {
56398       result = (darg)->GetNaturalSize();
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56414   return jresult;
56415 }
56416
56417
56418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56419   void * jresult ;
56420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56421   SwigDirector_ViewImpl *darg = 0;
56422   Dali::Vector3 result;
56423
56424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56425   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56426   {
56427     try {
56428       result = (darg)->GetNaturalSizeSwigPublic();
56429     } catch (std::out_of_range& e) {
56430       {
56431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56432       };
56433     } catch (std::exception& e) {
56434       {
56435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56440       };
56441     }
56442   }
56443   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56444   return jresult;
56445 }
56446
56447
56448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56449   float jresult ;
56450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56451   Dali::Actor *arg2 = 0 ;
56452   Dali::Dimension::Type arg3 ;
56453   SwigDirector_ViewImpl *darg = 0;
56454   float result;
56455
56456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56457   arg2 = (Dali::Actor *)jarg2;
56458   if (!arg2) {
56459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56460     return 0;
56461   }
56462   arg3 = (Dali::Dimension::Type)jarg3;
56463   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56464   {
56465     try {
56466       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56467     } catch (std::out_of_range& e) {
56468       {
56469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56470       };
56471     } catch (std::exception& e) {
56472       {
56473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (...) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56478       };
56479     }
56480   }
56481   jresult = result;
56482   return jresult;
56483 }
56484
56485
56486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56487   float jresult ;
56488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56489   Dali::Actor *arg2 = 0 ;
56490   Dali::Dimension::Type arg3 ;
56491   SwigDirector_ViewImpl *darg = 0;
56492   float result;
56493
56494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56495   arg2 = (Dali::Actor *)jarg2;
56496   if (!arg2) {
56497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56498     return 0;
56499   }
56500   arg3 = (Dali::Dimension::Type)jarg3;
56501   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56502   {
56503     try {
56504       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56505     } catch (std::out_of_range& e) {
56506       {
56507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56508       };
56509     } catch (std::exception& e) {
56510       {
56511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56512       };
56513     } catch (...) {
56514       {
56515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56516       };
56517     }
56518   }
56519   jresult = result;
56520   return jresult;
56521 }
56522
56523
56524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56525   float jresult ;
56526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56527   float arg2 ;
56528   SwigDirector_ViewImpl *darg = 0;
56529   float result;
56530
56531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56532   arg2 = (float)jarg2;
56533   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56534   {
56535     try {
56536       result = (float)(darg)->GetHeightForWidth(arg2);
56537     } catch (std::out_of_range& e) {
56538       {
56539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56540       };
56541     } catch (std::exception& e) {
56542       {
56543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56544       };
56545     } catch (...) {
56546       {
56547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56548       };
56549     }
56550   }
56551   jresult = result;
56552   return jresult;
56553 }
56554
56555
56556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56557   float jresult ;
56558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56559   float arg2 ;
56560   SwigDirector_ViewImpl *darg = 0;
56561   float result;
56562
56563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56564   arg2 = (float)jarg2;
56565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56566   {
56567     try {
56568       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56569     } catch (std::out_of_range& e) {
56570       {
56571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56572       };
56573     } catch (std::exception& e) {
56574       {
56575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (...) {
56578       {
56579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56580       };
56581     }
56582   }
56583   jresult = result;
56584   return jresult;
56585 }
56586
56587
56588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56589   float jresult ;
56590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56591   float arg2 ;
56592   SwigDirector_ViewImpl *darg = 0;
56593   float result;
56594
56595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56596   arg2 = (float)jarg2;
56597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56598   {
56599     try {
56600       result = (float)(darg)->GetWidthForHeight(arg2);
56601     } catch (std::out_of_range& e) {
56602       {
56603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56604       };
56605     } catch (std::exception& e) {
56606       {
56607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56608       };
56609     } catch (...) {
56610       {
56611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56612       };
56613     }
56614   }
56615   jresult = result;
56616   return jresult;
56617 }
56618
56619
56620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56621   float jresult ;
56622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56623   float arg2 ;
56624   SwigDirector_ViewImpl *darg = 0;
56625   float result;
56626
56627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56628   arg2 = (float)jarg2;
56629   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56630   {
56631     try {
56632       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56633     } catch (std::out_of_range& e) {
56634       {
56635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56636       };
56637     } catch (std::exception& e) {
56638       {
56639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (...) {
56642       {
56643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56644       };
56645     }
56646   }
56647   jresult = result;
56648   return jresult;
56649 }
56650
56651
56652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56653   unsigned int jresult ;
56654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56655   Dali::Dimension::Type arg2 ;
56656   SwigDirector_ViewImpl *darg = 0;
56657   bool result;
56658
56659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56660   arg2 = (Dali::Dimension::Type)jarg2;
56661   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56662   {
56663     try {
56664       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56665     } catch (std::out_of_range& e) {
56666       {
56667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56668       };
56669     } catch (std::exception& e) {
56670       {
56671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56672       };
56673     } catch (...) {
56674       {
56675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56676       };
56677     }
56678   }
56679   jresult = result;
56680   return jresult;
56681 }
56682
56683
56684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56685   unsigned int jresult ;
56686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56687   Dali::Dimension::Type arg2 ;
56688   SwigDirector_ViewImpl *darg = 0;
56689   bool result;
56690
56691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56692   arg2 = (Dali::Dimension::Type)jarg2;
56693   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56694   {
56695     try {
56696       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56697     } catch (std::out_of_range& e) {
56698       {
56699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (std::exception& e) {
56702       {
56703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56704       };
56705     } catch (...) {
56706       {
56707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56708       };
56709     }
56710   }
56711   jresult = result;
56712   return jresult;
56713 }
56714
56715
56716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56717   unsigned int jresult ;
56718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56719   SwigDirector_ViewImpl *darg = 0;
56720   bool result;
56721
56722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56724   {
56725     try {
56726       result = (bool)(darg)->RelayoutDependentOnChildren();
56727     } catch (std::out_of_range& e) {
56728       {
56729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56730       };
56731     } catch (std::exception& e) {
56732       {
56733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (...) {
56736       {
56737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56738       };
56739     }
56740   }
56741   jresult = result;
56742   return jresult;
56743 }
56744
56745
56746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56747   unsigned int jresult ;
56748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56749   SwigDirector_ViewImpl *darg = 0;
56750   bool result;
56751
56752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56754   {
56755     try {
56756       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56757     } catch (std::out_of_range& e) {
56758       {
56759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (std::exception& e) {
56762       {
56763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (...) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56768       };
56769     }
56770   }
56771   jresult = result;
56772   return jresult;
56773 }
56774
56775
56776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56778   Dali::Dimension::Type arg2 ;
56779   SwigDirector_ViewImpl *darg = 0;
56780
56781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56782   arg2 = (Dali::Dimension::Type)jarg2;
56783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56784   {
56785     try {
56786       (darg)->OnCalculateRelayoutSize(arg2);
56787     } catch (std::out_of_range& e) {
56788       {
56789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56790       };
56791     } catch (std::exception& e) {
56792       {
56793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56794       };
56795     } catch (...) {
56796       {
56797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56798       };
56799     }
56800   }
56801 }
56802
56803
56804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56806   Dali::Dimension::Type arg2 ;
56807   SwigDirector_ViewImpl *darg = 0;
56808
56809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56810   arg2 = (Dali::Dimension::Type)jarg2;
56811   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56812   {
56813     try {
56814       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56815     } catch (std::out_of_range& e) {
56816       {
56817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56818       };
56819     } catch (std::exception& e) {
56820       {
56821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56822       };
56823     } catch (...) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56826       };
56827     }
56828   }
56829 }
56830
56831
56832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56834   float arg2 ;
56835   Dali::Dimension::Type arg3 ;
56836   SwigDirector_ViewImpl *darg = 0;
56837
56838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56839   arg2 = (float)jarg2;
56840   arg3 = (Dali::Dimension::Type)jarg3;
56841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56842   {
56843     try {
56844       (darg)->OnLayoutNegotiated(arg2,arg3);
56845     } catch (std::out_of_range& e) {
56846       {
56847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56848       };
56849     } catch (std::exception& e) {
56850       {
56851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56852       };
56853     } catch (...) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56856       };
56857     }
56858   }
56859 }
56860
56861
56862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56864   float arg2 ;
56865   Dali::Dimension::Type arg3 ;
56866   SwigDirector_ViewImpl *darg = 0;
56867
56868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56869   arg2 = (float)jarg2;
56870   arg3 = (Dali::Dimension::Type)jarg3;
56871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56872   {
56873     try {
56874       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
56875     } catch (std::out_of_range& e) {
56876       {
56877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56878       };
56879     } catch (std::exception& e) {
56880       {
56881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56886       };
56887     }
56888   }
56889 }
56890
56891
56892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
56893   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56894
56895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56896   {
56897     try {
56898       (arg1)->OnInitialize();
56899     } catch (std::out_of_range& e) {
56900       {
56901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56902       };
56903     } catch (std::exception& e) {
56904       {
56905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56910       };
56911     }
56912   }
56913 }
56914
56915
56916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56918
56919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56920   {
56921     try {
56922       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56923     } catch (std::out_of_range& e) {
56924       {
56925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56926       };
56927     } catch (std::exception& e) {
56928       {
56929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56930       };
56931     } catch (...) {
56932       {
56933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56934       };
56935     }
56936   }
56937 }
56938
56939
56940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56942   Dali::Actor *arg2 = 0 ;
56943
56944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56945   arg2 = (Dali::Actor *)jarg2;
56946   if (!arg2) {
56947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56948     return ;
56949   }
56950   {
56951     try {
56952       (arg1)->OnControlChildAdd(*arg2);
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56964       };
56965     }
56966   }
56967 }
56968
56969
56970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56972   Dali::Actor *arg2 = 0 ;
56973
56974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56975   arg2 = (Dali::Actor *)jarg2;
56976   if (!arg2) {
56977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56978     return ;
56979   }
56980   {
56981     try {
56982       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
56983     } catch (std::out_of_range& e) {
56984       {
56985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56986       };
56987     } catch (std::exception& e) {
56988       {
56989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56990       };
56991     } catch (...) {
56992       {
56993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56994       };
56995     }
56996   }
56997 }
56998
56999
57000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57002   Dali::Actor *arg2 = 0 ;
57003
57004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57005   arg2 = (Dali::Actor *)jarg2;
57006   if (!arg2) {
57007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57008     return ;
57009   }
57010   {
57011     try {
57012       (arg1)->OnControlChildRemove(*arg2);
57013     } catch (std::out_of_range& e) {
57014       {
57015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57016       };
57017     } catch (std::exception& e) {
57018       {
57019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57020       };
57021     } catch (...) {
57022       {
57023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57024       };
57025     }
57026   }
57027 }
57028
57029
57030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57032   Dali::Actor *arg2 = 0 ;
57033
57034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57035   arg2 = (Dali::Actor *)jarg2;
57036   if (!arg2) {
57037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57038     return ;
57039   }
57040   {
57041     try {
57042       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57043     } catch (std::out_of_range& e) {
57044       {
57045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57046       };
57047     } catch (std::exception& e) {
57048       {
57049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57050       };
57051     } catch (...) {
57052       {
57053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57054       };
57055     }
57056   }
57057 }
57058
57059
57060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57062   Dali::Toolkit::StyleManager arg2 ;
57063   Dali::StyleChange::Type arg3 ;
57064   Dali::Toolkit::StyleManager *argp2 ;
57065
57066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57067   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57068   if (!argp2) {
57069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57070     return ;
57071   }
57072   arg2 = *argp2;
57073   arg3 = (Dali::StyleChange::Type)jarg3;
57074   {
57075     try {
57076       (arg1)->OnStyleChange(arg2,arg3);
57077     } catch (std::out_of_range& e) {
57078       {
57079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57080       };
57081     } catch (std::exception& e) {
57082       {
57083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57084       };
57085     } catch (...) {
57086       {
57087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57088       };
57089     }
57090   }
57091 }
57092
57093
57094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57096   Dali::Toolkit::StyleManager arg2 ;
57097   Dali::StyleChange::Type arg3 ;
57098   Dali::Toolkit::StyleManager *argp2 ;
57099
57100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57101   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57102   if (!argp2) {
57103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57104     return ;
57105   }
57106   arg2 = *argp2;
57107   arg3 = (Dali::StyleChange::Type)jarg3;
57108   {
57109     try {
57110       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57111     } catch (std::out_of_range& e) {
57112       {
57113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57114       };
57115     } catch (std::exception& e) {
57116       {
57117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57118       };
57119     } catch (...) {
57120       {
57121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57122       };
57123     }
57124   }
57125 }
57126
57127
57128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57129   unsigned int jresult ;
57130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57131   bool result;
57132
57133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57134   {
57135     try {
57136       result = (bool)(arg1)->OnAccessibilityActivated();
57137     } catch (std::out_of_range& e) {
57138       {
57139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57140       };
57141     } catch (std::exception& e) {
57142       {
57143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57144       };
57145     } catch (...) {
57146       {
57147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57148       };
57149     }
57150   }
57151   jresult = result;
57152   return jresult;
57153 }
57154
57155
57156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57157   unsigned int jresult ;
57158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57159   bool result;
57160
57161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57162   {
57163     try {
57164       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57165     } catch (std::out_of_range& e) {
57166       {
57167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57168       };
57169     } catch (std::exception& e) {
57170       {
57171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57172       };
57173     } catch (...) {
57174       {
57175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57176       };
57177     }
57178   }
57179   jresult = result;
57180   return jresult;
57181 }
57182
57183
57184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57185   unsigned int jresult ;
57186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57187   Dali::PanGesture arg2 ;
57188   Dali::PanGesture *argp2 ;
57189   bool result;
57190
57191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57192   argp2 = (Dali::PanGesture *)jarg2;
57193   if (!argp2) {
57194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57195     return 0;
57196   }
57197   arg2 = *argp2;
57198   {
57199     try {
57200       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57201     } catch (std::out_of_range& e) {
57202       {
57203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57204       };
57205     } catch (std::exception& e) {
57206       {
57207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57208       };
57209     } catch (...) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57212       };
57213     }
57214   }
57215   jresult = result;
57216   return jresult;
57217 }
57218
57219
57220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57221   unsigned int jresult ;
57222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57223   Dali::PanGesture arg2 ;
57224   Dali::PanGesture *argp2 ;
57225   bool result;
57226
57227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57228   argp2 = (Dali::PanGesture *)jarg2;
57229   if (!argp2) {
57230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57231     return 0;
57232   }
57233   arg2 = *argp2;
57234   {
57235     try {
57236       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57237     } catch (std::out_of_range& e) {
57238       {
57239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (std::exception& e) {
57242       {
57243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57244       };
57245     } catch (...) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57248       };
57249     }
57250   }
57251   jresult = result;
57252   return jresult;
57253 }
57254
57255
57256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57257   unsigned int jresult ;
57258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57259   Dali::TouchEvent *arg2 = 0 ;
57260   bool result;
57261
57262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57263   arg2 = (Dali::TouchEvent *)jarg2;
57264   if (!arg2) {
57265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57266     return 0;
57267   }
57268   {
57269     try {
57270       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57271     } catch (std::out_of_range& e) {
57272       {
57273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57274       };
57275     } catch (std::exception& e) {
57276       {
57277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57278       };
57279     } catch (...) {
57280       {
57281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57282       };
57283     }
57284   }
57285   jresult = result;
57286   return jresult;
57287 }
57288
57289
57290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57291   unsigned int jresult ;
57292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57293   Dali::TouchEvent *arg2 = 0 ;
57294   bool result;
57295
57296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57297   arg2 = (Dali::TouchEvent *)jarg2;
57298   if (!arg2) {
57299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57300     return 0;
57301   }
57302   {
57303     try {
57304       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57305     } catch (std::out_of_range& e) {
57306       {
57307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57308       };
57309     } catch (std::exception& e) {
57310       {
57311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57312       };
57313     } catch (...) {
57314       {
57315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57316       };
57317     }
57318   }
57319   jresult = result;
57320   return jresult;
57321 }
57322
57323
57324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57325   unsigned int jresult ;
57326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57327   bool arg2 ;
57328   bool result;
57329
57330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57331   arg2 = jarg2 ? true : false;
57332   {
57333     try {
57334       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57335     } catch (std::out_of_range& e) {
57336       {
57337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57338       };
57339     } catch (std::exception& e) {
57340       {
57341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57342       };
57343     } catch (...) {
57344       {
57345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57346       };
57347     }
57348   }
57349   jresult = result;
57350   return jresult;
57351 }
57352
57353
57354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57355   unsigned int jresult ;
57356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57357   bool arg2 ;
57358   bool result;
57359
57360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57361   arg2 = jarg2 ? true : false;
57362   {
57363     try {
57364       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57365     } catch (std::out_of_range& e) {
57366       {
57367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (std::exception& e) {
57370       {
57371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (...) {
57374       {
57375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57376       };
57377     }
57378   }
57379   jresult = result;
57380   return jresult;
57381 }
57382
57383
57384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57385   unsigned int jresult ;
57386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57387   bool result;
57388
57389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57390   {
57391     try {
57392       result = (bool)(arg1)->OnAccessibilityZoom();
57393     } catch (std::out_of_range& e) {
57394       {
57395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (std::exception& e) {
57398       {
57399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57404       };
57405     }
57406   }
57407   jresult = result;
57408   return jresult;
57409 }
57410
57411
57412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57413   unsigned int jresult ;
57414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57415   bool result;
57416
57417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57418   {
57419     try {
57420       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57421     } catch (std::out_of_range& e) {
57422       {
57423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57424       };
57425     } catch (std::exception& e) {
57426       {
57427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57428       };
57429     } catch (...) {
57430       {
57431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57432       };
57433     }
57434   }
57435   jresult = result;
57436   return jresult;
57437 }
57438
57439
57440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57442
57443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57444   {
57445     try {
57446       (arg1)->OnKeyInputFocusGained();
57447     } catch (std::out_of_range& e) {
57448       {
57449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57450       };
57451     } catch (std::exception& e) {
57452       {
57453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57454       };
57455     } catch (...) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57458       };
57459     }
57460   }
57461 }
57462
57463
57464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57466
57467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57468   {
57469     try {
57470       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57471     } catch (std::out_of_range& e) {
57472       {
57473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57474       };
57475     } catch (std::exception& e) {
57476       {
57477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57478       };
57479     } catch (...) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57482       };
57483     }
57484   }
57485 }
57486
57487
57488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57490
57491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57492   {
57493     try {
57494       (arg1)->OnKeyInputFocusLost();
57495     } catch (std::out_of_range& e) {
57496       {
57497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57498       };
57499     } catch (std::exception& e) {
57500       {
57501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57502       };
57503     } catch (...) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57506       };
57507     }
57508   }
57509 }
57510
57511
57512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57514
57515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57516   {
57517     try {
57518       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57519     } catch (std::out_of_range& e) {
57520       {
57521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57522       };
57523     } catch (std::exception& e) {
57524       {
57525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57526       };
57527     } catch (...) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57530       };
57531     }
57532   }
57533 }
57534
57535
57536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57537   void * jresult ;
57538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57539   Dali::Actor arg2 ;
57540   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57541   bool arg4 ;
57542   Dali::Actor *argp2 ;
57543   Dali::Actor result;
57544
57545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57546   argp2 = (Dali::Actor *)jarg2;
57547   if (!argp2) {
57548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57549     return 0;
57550   }
57551   arg2 = *argp2;
57552   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57553   arg4 = jarg4 ? true : false;
57554   {
57555     try {
57556       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57557     } catch (std::out_of_range& e) {
57558       {
57559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57560       };
57561     } catch (std::exception& e) {
57562       {
57563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57564       };
57565     } catch (...) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57568       };
57569     }
57570   }
57571   jresult = new Dali::Actor((const Dali::Actor &)result);
57572   return jresult;
57573 }
57574
57575
57576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57577   void * jresult ;
57578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57579   Dali::Actor arg2 ;
57580   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57581   bool arg4 ;
57582   Dali::Actor *argp2 ;
57583   Dali::Actor result;
57584
57585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57586   argp2 = (Dali::Actor *)jarg2;
57587   if (!argp2) {
57588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57589     return 0;
57590   }
57591   arg2 = *argp2;
57592   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57593   arg4 = jarg4 ? true : false;
57594   {
57595     try {
57596       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57597     } catch (std::out_of_range& e) {
57598       {
57599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57600       };
57601     } catch (std::exception& e) {
57602       {
57603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (...) {
57606       {
57607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57608       };
57609     }
57610   }
57611   jresult = new Dali::Actor((const Dali::Actor &)result);
57612   return jresult;
57613 }
57614
57615
57616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57618   Dali::Actor arg2 ;
57619   Dali::Actor *argp2 ;
57620
57621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57622   argp2 = (Dali::Actor *)jarg2;
57623   if (!argp2) {
57624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57625     return ;
57626   }
57627   arg2 = *argp2;
57628   {
57629     try {
57630       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57631     } catch (std::out_of_range& e) {
57632       {
57633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57634       };
57635     } catch (std::exception& e) {
57636       {
57637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57638       };
57639     } catch (...) {
57640       {
57641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57642       };
57643     }
57644   }
57645 }
57646
57647
57648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57650   Dali::Actor arg2 ;
57651   Dali::Actor *argp2 ;
57652
57653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57654   argp2 = (Dali::Actor *)jarg2;
57655   if (!argp2) {
57656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57657     return ;
57658   }
57659   arg2 = *argp2;
57660   {
57661     try {
57662       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57663     } catch (std::out_of_range& e) {
57664       {
57665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57666       };
57667     } catch (std::exception& e) {
57668       {
57669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57670       };
57671     } catch (...) {
57672       {
57673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57674       };
57675     }
57676   }
57677 }
57678
57679
57680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57681   unsigned int jresult ;
57682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57683   bool result;
57684
57685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57686   {
57687     try {
57688       result = (bool)(arg1)->OnKeyboardEnter();
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 = result;
57704   return jresult;
57705 }
57706
57707
57708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57709   unsigned int jresult ;
57710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57711   bool result;
57712
57713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57714   {
57715     try {
57716       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
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 = result;
57732   return jresult;
57733 }
57734
57735
57736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57738   Dali::PinchGesture *arg2 = 0 ;
57739
57740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57741   arg2 = (Dali::PinchGesture *)jarg2;
57742   if (!arg2) {
57743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57744     return ;
57745   }
57746   {
57747     try {
57748       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57749     } catch (std::out_of_range& e) {
57750       {
57751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57752       };
57753     } catch (std::exception& e) {
57754       {
57755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57756       };
57757     } catch (...) {
57758       {
57759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57760       };
57761     }
57762   }
57763 }
57764
57765
57766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57768   Dali::PinchGesture *arg2 = 0 ;
57769
57770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57771   arg2 = (Dali::PinchGesture *)jarg2;
57772   if (!arg2) {
57773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57774     return ;
57775   }
57776   {
57777     try {
57778       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57779     } catch (std::out_of_range& e) {
57780       {
57781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57782       };
57783     } catch (std::exception& e) {
57784       {
57785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57786       };
57787     } catch (...) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57790       };
57791     }
57792   }
57793 }
57794
57795
57796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57798   Dali::PanGesture *arg2 = 0 ;
57799
57800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57801   arg2 = (Dali::PanGesture *)jarg2;
57802   if (!arg2) {
57803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57804     return ;
57805   }
57806   {
57807     try {
57808       (arg1)->OnPan((Dali::PanGesture const &)*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_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57828   Dali::PanGesture *arg2 = 0 ;
57829
57830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57831   arg2 = (Dali::PanGesture *)jarg2;
57832   if (!arg2) {
57833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57834     return ;
57835   }
57836   {
57837     try {
57838       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57839     } catch (std::out_of_range& e) {
57840       {
57841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57842       };
57843     } catch (std::exception& e) {
57844       {
57845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57846       };
57847     } catch (...) {
57848       {
57849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57850       };
57851     }
57852   }
57853 }
57854
57855
57856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57858   Dali::TapGesture *arg2 = 0 ;
57859
57860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57861   arg2 = (Dali::TapGesture *)jarg2;
57862   if (!arg2) {
57863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57864     return ;
57865   }
57866   {
57867     try {
57868       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
57869     } catch (std::out_of_range& e) {
57870       {
57871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57872       };
57873     } catch (std::exception& e) {
57874       {
57875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57876       };
57877     } catch (...) {
57878       {
57879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57880       };
57881     }
57882   }
57883 }
57884
57885
57886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57888   Dali::TapGesture *arg2 = 0 ;
57889
57890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57891   arg2 = (Dali::TapGesture *)jarg2;
57892   if (!arg2) {
57893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57894     return ;
57895   }
57896   {
57897     try {
57898       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57899     } catch (std::out_of_range& e) {
57900       {
57901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57902       };
57903     } catch (std::exception& e) {
57904       {
57905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57906       };
57907     } catch (...) {
57908       {
57909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57910       };
57911     }
57912   }
57913 }
57914
57915
57916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57918   Dali::LongPressGesture *arg2 = 0 ;
57919
57920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57921   arg2 = (Dali::LongPressGesture *)jarg2;
57922   if (!arg2) {
57923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57924     return ;
57925   }
57926   {
57927     try {
57928       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57929     } catch (std::out_of_range& e) {
57930       {
57931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57932       };
57933     } catch (std::exception& e) {
57934       {
57935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57936       };
57937     } catch (...) {
57938       {
57939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57940       };
57941     }
57942   }
57943 }
57944
57945
57946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57948   Dali::LongPressGesture *arg2 = 0 ;
57949
57950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57951   arg2 = (Dali::LongPressGesture *)jarg2;
57952   if (!arg2) {
57953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57954     return ;
57955   }
57956   {
57957     try {
57958       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
57959     } catch (std::out_of_range& e) {
57960       {
57961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57962       };
57963     } catch (std::exception& e) {
57964       {
57965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57966       };
57967     } catch (...) {
57968       {
57969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57970       };
57971     }
57972   }
57973 }
57974
57975
57976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57978   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57979   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57980
57981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57982   arg2 = (Dali::SlotObserver *)jarg2;
57983   arg3 = (Dali::CallbackBase *)jarg3;
57984   {
57985     try {
57986       (arg1)->SignalConnected(arg2,arg3);
57987     } catch (std::out_of_range& e) {
57988       {
57989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57990       };
57991     } catch (std::exception& e) {
57992       {
57993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57994       };
57995     } catch (...) {
57996       {
57997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57998       };
57999     }
58000   }
58001 }
58002
58003
58004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58006   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58007   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58008
58009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58010   arg2 = (Dali::SlotObserver *)jarg2;
58011   arg3 = (Dali::CallbackBase *)jarg3;
58012   {
58013     try {
58014       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58015     } catch (std::out_of_range& e) {
58016       {
58017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58018       };
58019     } catch (std::exception& e) {
58020       {
58021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58022       };
58023     } catch (...) {
58024       {
58025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58026       };
58027     }
58028   }
58029 }
58030
58031
58032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58034   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58035   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58036
58037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58038   arg2 = (Dali::SlotObserver *)jarg2;
58039   arg3 = (Dali::CallbackBase *)jarg3;
58040   {
58041     try {
58042       (arg1)->SignalDisconnected(arg2,arg3);
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58050       };
58051     } catch (...) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58054       };
58055     }
58056   }
58057 }
58058
58059
58060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58062   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58063   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58064
58065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58066   arg2 = (Dali::SlotObserver *)jarg2;
58067   arg3 = (Dali::CallbackBase *)jarg3;
58068   {
58069     try {
58070       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58071     } catch (std::out_of_range& e) {
58072       {
58073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58074       };
58075     } catch (std::exception& e) {
58076       {
58077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58078       };
58079     } catch (...) {
58080       {
58081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58082       };
58083     }
58084   }
58085 }
58086
58087
58088 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) {
58089   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58090   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58091   if (director) {
58092     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);
58093   }
58094 }
58095
58096
58097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58098   void * jresult ;
58099   Dali::Toolkit::Control *arg1 = 0 ;
58100   Dali::Toolkit::Internal::Control *result = 0 ;
58101
58102   arg1 = (Dali::Toolkit::Control *)jarg1;
58103   if (!arg1) {
58104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58105     return 0;
58106   }
58107   {
58108     try {
58109       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58110     } catch (std::out_of_range& e) {
58111       {
58112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58113       };
58114     } catch (std::exception& e) {
58115       {
58116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58117       };
58118     } catch (...) {
58119       {
58120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58121       };
58122     }
58123   }
58124   jresult = (void *)result;
58125   return jresult;
58126 }
58127
58128
58129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58130   int jresult ;
58131   int result;
58132
58133   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58134   jresult = (int)result;
58135   return jresult;
58136 }
58137
58138
58139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58140   int jresult ;
58141   int result;
58142
58143   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58144   jresult = (int)result;
58145   return jresult;
58146 }
58147
58148
58149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58150   int jresult ;
58151   int result;
58152
58153   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58154   jresult = (int)result;
58155   return jresult;
58156 }
58157
58158
58159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58160   int jresult ;
58161   int result;
58162
58163   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58164   jresult = (int)result;
58165   return jresult;
58166 }
58167
58168
58169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58170   int jresult ;
58171   int result;
58172
58173   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58174   jresult = (int)result;
58175   return jresult;
58176 }
58177
58178
58179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58180   void * jresult ;
58181   Dali::Toolkit::Control::Property *result = 0 ;
58182
58183   {
58184     try {
58185       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58186     } catch (std::out_of_range& e) {
58187       {
58188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (std::exception& e) {
58191       {
58192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58193       };
58194     } catch (...) {
58195       {
58196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58197       };
58198     }
58199   }
58200   jresult = (void *)result;
58201   return jresult;
58202 }
58203
58204
58205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58206   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58207
58208   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58209   {
58210     try {
58211       delete arg1;
58212     } catch (std::out_of_range& e) {
58213       {
58214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58215       };
58216     } catch (std::exception& e) {
58217       {
58218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58219       };
58220     } catch (...) {
58221       {
58222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58223       };
58224     }
58225   }
58226 }
58227
58228
58229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58230   void * jresult ;
58231   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58232
58233   {
58234     try {
58235       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58236     } catch (std::out_of_range& e) {
58237       {
58238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58239       };
58240     } catch (std::exception& e) {
58241       {
58242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58243       };
58244     } catch (...) {
58245       {
58246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58247       };
58248     }
58249   }
58250   jresult = (void *)result;
58251   return jresult;
58252 }
58253
58254
58255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58256   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58257
58258   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58259   {
58260     try {
58261       delete arg1;
58262     } catch (std::out_of_range& e) {
58263       {
58264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58265       };
58266     } catch (std::exception& e) {
58267       {
58268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58269       };
58270     } catch (...) {
58271       {
58272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58273       };
58274     }
58275   }
58276 }
58277
58278
58279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58280   void * jresult ;
58281   Dali::Toolkit::Control result;
58282
58283   {
58284     try {
58285       result = Dali::Toolkit::Control::New();
58286     } catch (std::out_of_range& e) {
58287       {
58288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58289       };
58290     } catch (std::exception& e) {
58291       {
58292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58293       };
58294     } catch (...) {
58295       {
58296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58297       };
58298     }
58299   }
58300   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58301   return jresult;
58302 }
58303
58304
58305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58306   void * jresult ;
58307   Dali::Toolkit::Control *result = 0 ;
58308
58309   {
58310     try {
58311       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58312     } catch (std::out_of_range& e) {
58313       {
58314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58315       };
58316     } catch (std::exception& e) {
58317       {
58318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58319       };
58320     } catch (...) {
58321       {
58322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58323       };
58324     }
58325   }
58326   jresult = (void *)result;
58327   return jresult;
58328 }
58329
58330
58331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58332   void * jresult ;
58333   Dali::Toolkit::Control *arg1 = 0 ;
58334   Dali::Toolkit::Control *result = 0 ;
58335
58336   arg1 = (Dali::Toolkit::Control *)jarg1;
58337   if (!arg1) {
58338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58339     return 0;
58340   }
58341   {
58342     try {
58343       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58344     } catch (std::out_of_range& e) {
58345       {
58346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58347       };
58348     } catch (std::exception& e) {
58349       {
58350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58351       };
58352     } catch (...) {
58353       {
58354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58355       };
58356     }
58357   }
58358   jresult = (void *)result;
58359   return jresult;
58360 }
58361
58362
58363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58364   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58365
58366   arg1 = (Dali::Toolkit::Control *)jarg1;
58367   {
58368     try {
58369       delete arg1;
58370     } catch (std::out_of_range& e) {
58371       {
58372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58373       };
58374     } catch (std::exception& e) {
58375       {
58376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58377       };
58378     } catch (...) {
58379       {
58380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58381       };
58382     }
58383   }
58384 }
58385
58386
58387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58388   void * jresult ;
58389   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58390   Dali::Toolkit::Control *arg2 = 0 ;
58391   Dali::Toolkit::Control *result = 0 ;
58392
58393   arg1 = (Dali::Toolkit::Control *)jarg1;
58394   arg2 = (Dali::Toolkit::Control *)jarg2;
58395   if (!arg2) {
58396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58397     return 0;
58398   }
58399   {
58400     try {
58401       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58402     } catch (std::out_of_range& e) {
58403       {
58404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58405       };
58406     } catch (std::exception& e) {
58407       {
58408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58409       };
58410     } catch (...) {
58411       {
58412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58413       };
58414     }
58415   }
58416   jresult = (void *)result;
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58422   void * jresult ;
58423   Dali::BaseHandle arg1 ;
58424   Dali::BaseHandle *argp1 ;
58425   Dali::Toolkit::Control result;
58426
58427   argp1 = (Dali::BaseHandle *)jarg1;
58428   if (!argp1) {
58429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58430     return 0;
58431   }
58432   arg1 = *argp1;
58433   {
58434     try {
58435       result = Dali::Toolkit::Control::DownCast(arg1);
58436     } catch (std::out_of_range& e) {
58437       {
58438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (std::exception& e) {
58441       {
58442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (...) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58447       };
58448     }
58449   }
58450   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58451   return jresult;
58452 }
58453
58454
58455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58456   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58457
58458   arg1 = (Dali::Toolkit::Control *)jarg1;
58459   {
58460     try {
58461       (arg1)->SetKeyInputFocus();
58462     } catch (std::out_of_range& e) {
58463       {
58464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58465       };
58466     } catch (std::exception& e) {
58467       {
58468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58469       };
58470     } catch (...) {
58471       {
58472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58473       };
58474     }
58475   }
58476 }
58477
58478
58479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58480   unsigned int jresult ;
58481   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58482   bool result;
58483
58484   arg1 = (Dali::Toolkit::Control *)jarg1;
58485   {
58486     try {
58487       result = (bool)(arg1)->HasKeyInputFocus();
58488     } catch (std::out_of_range& e) {
58489       {
58490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58491       };
58492     } catch (std::exception& e) {
58493       {
58494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58495       };
58496     } catch (...) {
58497       {
58498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58499       };
58500     }
58501   }
58502   jresult = result;
58503   return jresult;
58504 }
58505
58506
58507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58508   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58509
58510   arg1 = (Dali::Toolkit::Control *)jarg1;
58511   {
58512     try {
58513       (arg1)->ClearKeyInputFocus();
58514     } catch (std::out_of_range& e) {
58515       {
58516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58517       };
58518     } catch (std::exception& e) {
58519       {
58520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58521       };
58522     } catch (...) {
58523       {
58524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58525       };
58526     }
58527   }
58528 }
58529
58530
58531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58532   void * jresult ;
58533   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58534   Dali::PinchGestureDetector result;
58535
58536   arg1 = (Dali::Toolkit::Control *)jarg1;
58537   {
58538     try {
58539       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58540     } catch (std::out_of_range& e) {
58541       {
58542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58543       };
58544     } catch (std::exception& e) {
58545       {
58546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58547       };
58548     } catch (...) {
58549       {
58550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58551       };
58552     }
58553   }
58554   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58555   return jresult;
58556 }
58557
58558
58559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58560   void * jresult ;
58561   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58562   Dali::PanGestureDetector result;
58563
58564   arg1 = (Dali::Toolkit::Control *)jarg1;
58565   {
58566     try {
58567       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58575       };
58576     } catch (...) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58579       };
58580     }
58581   }
58582   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58583   return jresult;
58584 }
58585
58586
58587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58588   void * jresult ;
58589   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58590   Dali::TapGestureDetector result;
58591
58592   arg1 = (Dali::Toolkit::Control *)jarg1;
58593   {
58594     try {
58595       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58596     } catch (std::out_of_range& e) {
58597       {
58598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58599       };
58600     } catch (std::exception& e) {
58601       {
58602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58607       };
58608     }
58609   }
58610   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58611   return jresult;
58612 }
58613
58614
58615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58616   void * jresult ;
58617   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58618   Dali::LongPressGestureDetector result;
58619
58620   arg1 = (Dali::Toolkit::Control *)jarg1;
58621   {
58622     try {
58623       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (...) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58635       };
58636     }
58637   }
58638   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58639   return jresult;
58640 }
58641
58642
58643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58644   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58645   std::string *arg2 = 0 ;
58646
58647   arg1 = (Dali::Toolkit::Control *)jarg1;
58648   if (!jarg2) {
58649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58650     return ;
58651   }
58652   std::string arg2_str(jarg2);
58653   arg2 = &arg2_str;
58654   {
58655     try {
58656       (arg1)->SetStyleName((std::string const &)*arg2);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58668       };
58669     }
58670   }
58671
58672   //argout typemap for const std::string&
58673
58674 }
58675
58676
58677 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58678   char * jresult ;
58679   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58680   std::string *result = 0 ;
58681
58682   arg1 = (Dali::Toolkit::Control *)jarg1;
58683   {
58684     try {
58685       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58686     } catch (std::out_of_range& e) {
58687       {
58688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58689       };
58690     } catch (std::exception& e) {
58691       {
58692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58693       };
58694     } catch (...) {
58695       {
58696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58697       };
58698     }
58699   }
58700   jresult = SWIG_csharp_string_callback(result->c_str());
58701   return jresult;
58702 }
58703
58704
58705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58706   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58707   Dali::Vector4 *arg2 = 0 ;
58708
58709   arg1 = (Dali::Toolkit::Control *)jarg1;
58710   arg2 = (Dali::Vector4 *)jarg2;
58711   if (!arg2) {
58712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58713     return ;
58714   }
58715   {
58716     try {
58717       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58718     } catch (std::out_of_range& e) {
58719       {
58720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58721       };
58722     } catch (std::exception& e) {
58723       {
58724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58725       };
58726     } catch (...) {
58727       {
58728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58729       };
58730     }
58731   }
58732 }
58733
58734
58735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58736   void * jresult ;
58737   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58738   Dali::Vector4 result;
58739
58740   arg1 = (Dali::Toolkit::Control *)jarg1;
58741   {
58742     try {
58743       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58744     } catch (std::out_of_range& e) {
58745       {
58746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58747       };
58748     } catch (std::exception& e) {
58749       {
58750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58751       };
58752     } catch (...) {
58753       {
58754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58755       };
58756     }
58757   }
58758   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58759   return jresult;
58760 }
58761
58762
58763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58764   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58765   Dali::Image arg2 ;
58766   Dali::Image *argp2 ;
58767
58768   arg1 = (Dali::Toolkit::Control *)jarg1;
58769   argp2 = (Dali::Image *)jarg2;
58770   if (!argp2) {
58771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58772     return ;
58773   }
58774   arg2 = *argp2;
58775   {
58776     try {
58777       (arg1)->SetBackgroundImage(arg2);
58778     } catch (std::out_of_range& e) {
58779       {
58780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58781       };
58782     } catch (std::exception& e) {
58783       {
58784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58785       };
58786     } catch (...) {
58787       {
58788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58789       };
58790     }
58791   }
58792 }
58793
58794
58795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58796   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58797
58798   arg1 = (Dali::Toolkit::Control *)jarg1;
58799   {
58800     try {
58801       (arg1)->ClearBackground();
58802     } catch (std::out_of_range& e) {
58803       {
58804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58805       };
58806     } catch (std::exception& e) {
58807       {
58808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58809       };
58810     } catch (...) {
58811       {
58812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58813       };
58814     }
58815   }
58816 }
58817
58818
58819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58820   void * jresult ;
58821   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58822   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58823
58824   arg1 = (Dali::Toolkit::Control *)jarg1;
58825   {
58826     try {
58827       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58828     } catch (std::out_of_range& e) {
58829       {
58830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58831       };
58832     } catch (std::exception& e) {
58833       {
58834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58835       };
58836     } catch (...) {
58837       {
58838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58839       };
58840     }
58841   }
58842   jresult = (void *)result;
58843   return jresult;
58844 }
58845
58846
58847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58848   void * jresult ;
58849   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58850   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58851
58852   arg1 = (Dali::Toolkit::Control *)jarg1;
58853   {
58854     try {
58855       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58856     } catch (std::out_of_range& e) {
58857       {
58858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (std::exception& e) {
58861       {
58862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (...) {
58865       {
58866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58867       };
58868     }
58869   }
58870   jresult = (void *)result;
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58876   void * jresult ;
58877   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58878   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58879
58880   arg1 = (Dali::Toolkit::Control *)jarg1;
58881   {
58882     try {
58883       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58884     } catch (std::out_of_range& e) {
58885       {
58886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (std::exception& e) {
58889       {
58890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (...) {
58893       {
58894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58895       };
58896     }
58897   }
58898   jresult = (void *)result;
58899   return jresult;
58900 }
58901
58902
58903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58904   void * jresult ;
58905   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58906   Dali::Toolkit::Control *result = 0 ;
58907
58908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58909   if (!arg1) {
58910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58911     return 0;
58912   }
58913   {
58914     try {
58915       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (...) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58927       };
58928     }
58929   }
58930   jresult = (void *)result;
58931   return jresult;
58932 }
58933
58934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58935 {
58936   void * jresult;
58937   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58938   arg1 = (Dali::Toolkit::Control *)jarg1;
58939
58940   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58941
58942   Dali::Toolkit::TransitionData *arg2 = 0 ;
58943   Dali::Animation result;
58944
58945   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58946   if (!arg2) {
58947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58948     return 0;
58949   }
58950   {
58951     try {
58952       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (...) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58964       };
58965     }
58966   }
58967   jresult = new Dali::Animation((const Dali::Animation &)result);
58968   return jresult;
58969 }
58970
58971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
58972   void * jresult ;
58973   Dali::Toolkit::Control *arg1 = 0 ;
58974   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
58975
58976   arg1 = (Dali::Toolkit::Control *)jarg1;
58977   if (!arg1) {
58978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58979     return 0;
58980   }
58981   {
58982     try {
58983       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
58984     } catch (std::out_of_range& e) {
58985       {
58986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58987       };
58988     } catch (std::exception& e) {
58989       {
58990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58991       };
58992     } catch (...) {
58993       {
58994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58995       };
58996     }
58997   }
58998   jresult = (void *)result;
58999   return jresult;
59000 }
59001
59002
59003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59004   unsigned int jresult ;
59005   Dali::Toolkit::Control *arg1 = 0 ;
59006   bool result;
59007
59008   arg1 = (Dali::Toolkit::Control *)jarg1;
59009   if (!arg1) {
59010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59011     return 0;
59012   }
59013   {
59014     try {
59015       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
59016     } catch (std::out_of_range& e) {
59017       {
59018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59019       };
59020     } catch (std::exception& e) {
59021       {
59022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59023       };
59024     } catch (...) {
59025       {
59026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59027       };
59028     }
59029   }
59030   jresult = result;
59031   return jresult;
59032 }
59033
59034
59035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59036   void * jresult ;
59037   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59038
59039   {
59040     try {
59041       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59042     } catch (std::out_of_range& e) {
59043       {
59044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59045       };
59046     } catch (std::exception& e) {
59047       {
59048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59049       };
59050     } catch (...) {
59051       {
59052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59053       };
59054     }
59055   }
59056   jresult = (void *)result;
59057   return jresult;
59058 }
59059
59060
59061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59062   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59063
59064   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59065   {
59066     try {
59067       delete arg1;
59068     } catch (std::out_of_range& e) {
59069       {
59070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59071       };
59072     } catch (std::exception& e) {
59073       {
59074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59075       };
59076     } catch (...) {
59077       {
59078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59079       };
59080     }
59081   }
59082 }
59083
59084
59085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59086   void * jresult ;
59087   Dali::Toolkit::KeyInputFocusManager result;
59088
59089   {
59090     try {
59091       result = Dali::Toolkit::KeyInputFocusManager::Get();
59092     } catch (std::out_of_range& e) {
59093       {
59094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59095       };
59096     } catch (std::exception& e) {
59097       {
59098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59099       };
59100     } catch (...) {
59101       {
59102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59103       };
59104     }
59105   }
59106   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59107   return jresult;
59108 }
59109
59110
59111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59112   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59113   Dali::Toolkit::Control arg2 ;
59114   Dali::Toolkit::Control *argp2 ;
59115
59116   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59117   argp2 = (Dali::Toolkit::Control *)jarg2;
59118   if (!argp2) {
59119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59120     return ;
59121   }
59122   arg2 = *argp2;
59123   {
59124     try {
59125       (arg1)->SetFocus(arg2);
59126     } catch (std::out_of_range& e) {
59127       {
59128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59129       };
59130     } catch (std::exception& e) {
59131       {
59132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59133       };
59134     } catch (...) {
59135       {
59136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59137       };
59138     }
59139   }
59140 }
59141
59142
59143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59144   void * jresult ;
59145   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59146   Dali::Toolkit::Control result;
59147
59148   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59149   {
59150     try {
59151       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59152     } catch (std::out_of_range& e) {
59153       {
59154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59155       };
59156     } catch (std::exception& e) {
59157       {
59158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59159       };
59160     } catch (...) {
59161       {
59162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59163       };
59164     }
59165   }
59166   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59167   return jresult;
59168 }
59169
59170
59171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59172   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59173   Dali::Toolkit::Control arg2 ;
59174   Dali::Toolkit::Control *argp2 ;
59175
59176   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59177   argp2 = (Dali::Toolkit::Control *)jarg2;
59178   if (!argp2) {
59179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59180     return ;
59181   }
59182   arg2 = *argp2;
59183   {
59184     try {
59185       (arg1)->RemoveFocus(arg2);
59186     } catch (std::out_of_range& e) {
59187       {
59188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59189       };
59190     } catch (std::exception& e) {
59191       {
59192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59193       };
59194     } catch (...) {
59195       {
59196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59197       };
59198     }
59199   }
59200 }
59201
59202
59203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59204   void * jresult ;
59205   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59206   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59207
59208   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59209   {
59210     try {
59211       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59212     } catch (std::out_of_range& e) {
59213       {
59214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59215       };
59216     } catch (std::exception& e) {
59217       {
59218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59219       };
59220     } catch (...) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59223       };
59224     }
59225   }
59226   jresult = (void *)result;
59227   return jresult;
59228 }
59229
59230
59231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59232   void * jresult ;
59233   Dali::Toolkit::Alignment::Padding *result = 0 ;
59234
59235   {
59236     try {
59237       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59238     } catch (std::out_of_range& e) {
59239       {
59240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59241       };
59242     } catch (std::exception& e) {
59243       {
59244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59245       };
59246     } catch (...) {
59247       {
59248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59249       };
59250     }
59251   }
59252   jresult = (void *)result;
59253   return jresult;
59254 }
59255
59256
59257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59258   void * jresult ;
59259   float arg1 ;
59260   float arg2 ;
59261   float arg3 ;
59262   float arg4 ;
59263   Dali::Toolkit::Alignment::Padding *result = 0 ;
59264
59265   arg1 = (float)jarg1;
59266   arg2 = (float)jarg2;
59267   arg3 = (float)jarg3;
59268   arg4 = (float)jarg4;
59269   {
59270     try {
59271       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59272     } catch (std::out_of_range& e) {
59273       {
59274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59275       };
59276     } catch (std::exception& e) {
59277       {
59278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59279       };
59280     } catch (...) {
59281       {
59282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59283       };
59284     }
59285   }
59286   jresult = (void *)result;
59287   return jresult;
59288 }
59289
59290
59291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59292   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59293   float arg2 ;
59294
59295   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59296   arg2 = (float)jarg2;
59297   if (arg1) (arg1)->left = arg2;
59298 }
59299
59300
59301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59302   float jresult ;
59303   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59304   float result;
59305
59306   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59307   result = (float) ((arg1)->left);
59308   jresult = result;
59309   return jresult;
59310 }
59311
59312
59313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59314   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59315   float arg2 ;
59316
59317   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59318   arg2 = (float)jarg2;
59319   if (arg1) (arg1)->right = arg2;
59320 }
59321
59322
59323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59324   float jresult ;
59325   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59326   float result;
59327
59328   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59329   result = (float) ((arg1)->right);
59330   jresult = result;
59331   return jresult;
59332 }
59333
59334
59335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59336   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59337   float arg2 ;
59338
59339   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59340   arg2 = (float)jarg2;
59341   if (arg1) (arg1)->top = arg2;
59342 }
59343
59344
59345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59346   float jresult ;
59347   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59348   float result;
59349
59350   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59351   result = (float) ((arg1)->top);
59352   jresult = result;
59353   return jresult;
59354 }
59355
59356
59357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59358   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59359   float arg2 ;
59360
59361   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59362   arg2 = (float)jarg2;
59363   if (arg1) (arg1)->bottom = arg2;
59364 }
59365
59366
59367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59368   float jresult ;
59369   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59370   float result;
59371
59372   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59373   result = (float) ((arg1)->bottom);
59374   jresult = result;
59375   return jresult;
59376 }
59377
59378
59379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59380   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59381
59382   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59383   {
59384     try {
59385       delete arg1;
59386     } catch (std::out_of_range& e) {
59387       {
59388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59389       };
59390     } catch (std::exception& e) {
59391       {
59392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59393       };
59394     } catch (...) {
59395       {
59396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59397       };
59398     }
59399   }
59400 }
59401
59402
59403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59404   void * jresult ;
59405   Dali::Toolkit::Alignment *result = 0 ;
59406
59407   {
59408     try {
59409       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (...) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59421       };
59422     }
59423   }
59424   jresult = (void *)result;
59425   return jresult;
59426 }
59427
59428
59429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59430   void * jresult ;
59431   Dali::Toolkit::Alignment::Type arg1 ;
59432   Dali::Toolkit::Alignment::Type arg2 ;
59433   Dali::Toolkit::Alignment result;
59434
59435   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59436   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59437   {
59438     try {
59439       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59440     } catch (std::out_of_range& e) {
59441       {
59442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59443       };
59444     } catch (std::exception& e) {
59445       {
59446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59447       };
59448     } catch (...) {
59449       {
59450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59451       };
59452     }
59453   }
59454   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59460   void * jresult ;
59461   Dali::Toolkit::Alignment::Type arg1 ;
59462   Dali::Toolkit::Alignment result;
59463
59464   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59465   {
59466     try {
59467       result = Dali::Toolkit::Alignment::New(arg1);
59468     } catch (std::out_of_range& e) {
59469       {
59470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59471       };
59472     } catch (std::exception& e) {
59473       {
59474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (...) {
59477       {
59478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59479       };
59480     }
59481   }
59482   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59483   return jresult;
59484 }
59485
59486
59487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59488   void * jresult ;
59489   Dali::Toolkit::Alignment result;
59490
59491   {
59492     try {
59493       result = Dali::Toolkit::Alignment::New();
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59505       };
59506     }
59507   }
59508   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59514   void * jresult ;
59515   Dali::Toolkit::Alignment *arg1 = 0 ;
59516   Dali::Toolkit::Alignment *result = 0 ;
59517
59518   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59519   if (!arg1) {
59520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59521     return 0;
59522   }
59523   {
59524     try {
59525       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59526     } catch (std::out_of_range& e) {
59527       {
59528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59529       };
59530     } catch (std::exception& e) {
59531       {
59532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59533       };
59534     } catch (...) {
59535       {
59536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59537       };
59538     }
59539   }
59540   jresult = (void *)result;
59541   return jresult;
59542 }
59543
59544
59545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59546   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59547
59548   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59549   {
59550     try {
59551       delete arg1;
59552     } catch (std::out_of_range& e) {
59553       {
59554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59555       };
59556     } catch (std::exception& e) {
59557       {
59558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59559       };
59560     } catch (...) {
59561       {
59562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59563       };
59564     }
59565   }
59566 }
59567
59568
59569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59570   void * jresult ;
59571   Dali::BaseHandle arg1 ;
59572   Dali::BaseHandle *argp1 ;
59573   Dali::Toolkit::Alignment result;
59574
59575   argp1 = (Dali::BaseHandle *)jarg1;
59576   if (!argp1) {
59577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59578     return 0;
59579   }
59580   arg1 = *argp1;
59581   {
59582     try {
59583       result = Dali::Toolkit::Alignment::DownCast(arg1);
59584     } catch (std::out_of_range& e) {
59585       {
59586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59587       };
59588     } catch (std::exception& e) {
59589       {
59590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59591       };
59592     } catch (...) {
59593       {
59594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59595       };
59596     }
59597   }
59598   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59599   return jresult;
59600 }
59601
59602
59603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59604   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59605   Dali::Toolkit::Alignment::Type arg2 ;
59606
59607   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59608   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59609   {
59610     try {
59611       (arg1)->SetAlignmentType(arg2);
59612     } catch (std::out_of_range& e) {
59613       {
59614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59615       };
59616     } catch (std::exception& e) {
59617       {
59618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59619       };
59620     } catch (...) {
59621       {
59622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59623       };
59624     }
59625   }
59626 }
59627
59628
59629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59630   int jresult ;
59631   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59632   Dali::Toolkit::Alignment::Type result;
59633
59634   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59635   {
59636     try {
59637       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59638     } catch (std::out_of_range& e) {
59639       {
59640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (std::exception& e) {
59643       {
59644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59645       };
59646     } catch (...) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59649       };
59650     }
59651   }
59652   jresult = (int)result;
59653   return jresult;
59654 }
59655
59656
59657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59658   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59659   Dali::Toolkit::Alignment::Scaling arg2 ;
59660
59661   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59662   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59663   {
59664     try {
59665       (arg1)->SetScaling(arg2);
59666     } catch (std::out_of_range& e) {
59667       {
59668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59669       };
59670     } catch (std::exception& e) {
59671       {
59672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59673       };
59674     } catch (...) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59677       };
59678     }
59679   }
59680 }
59681
59682
59683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59684   int jresult ;
59685   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59686   Dali::Toolkit::Alignment::Scaling result;
59687
59688   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59689   {
59690     try {
59691       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59692     } catch (std::out_of_range& e) {
59693       {
59694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (std::exception& e) {
59697       {
59698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706   jresult = (int)result;
59707   return jresult;
59708 }
59709
59710
59711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59712   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59713   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59714
59715   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59716   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59717   if (!arg2) {
59718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59719     return ;
59720   }
59721   {
59722     try {
59723       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59724     } catch (std::out_of_range& e) {
59725       {
59726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59727       };
59728     } catch (std::exception& e) {
59729       {
59730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59731       };
59732     } catch (...) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59735       };
59736     }
59737   }
59738 }
59739
59740
59741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59742   void * jresult ;
59743   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59744   Dali::Toolkit::Alignment::Padding *result = 0 ;
59745
59746   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59747   {
59748     try {
59749       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59750     } catch (std::out_of_range& e) {
59751       {
59752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59753       };
59754     } catch (std::exception& e) {
59755       {
59756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59757       };
59758     } catch (...) {
59759       {
59760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59761       };
59762     }
59763   }
59764   jresult = (void *)result;
59765   return jresult;
59766 }
59767
59768
59769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59770   void * jresult ;
59771   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59772   Dali::Toolkit::Alignment *arg2 = 0 ;
59773   Dali::Toolkit::Alignment *result = 0 ;
59774
59775   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59776   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59777   if (!arg2) {
59778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59779     return 0;
59780   }
59781   {
59782     try {
59783       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59784     } catch (std::out_of_range& e) {
59785       {
59786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59787       };
59788     } catch (std::exception& e) {
59789       {
59790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (...) {
59793       {
59794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59795       };
59796     }
59797   }
59798   jresult = (void *)result;
59799   return jresult;
59800 }
59801
59802
59803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59804   int jresult ;
59805   int result;
59806
59807   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59808   jresult = (int)result;
59809   return jresult;
59810 }
59811
59812
59813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59814   int jresult ;
59815   int result;
59816
59817   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59818   jresult = (int)result;
59819   return jresult;
59820 }
59821
59822
59823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59824   int jresult ;
59825   int result;
59826
59827   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59828   jresult = (int)result;
59829   return jresult;
59830 }
59831
59832
59833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59834   int jresult ;
59835   int result;
59836
59837   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59838   jresult = (int)result;
59839   return jresult;
59840 }
59841
59842
59843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59844   int jresult ;
59845   int result;
59846
59847   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59848   jresult = (int)result;
59849   return jresult;
59850 }
59851
59852
59853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59854   int jresult ;
59855   int result;
59856
59857   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59858   jresult = (int)result;
59859   return jresult;
59860 }
59861
59862
59863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59864   int jresult ;
59865   int result;
59866
59867   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59868   jresult = (int)result;
59869   return jresult;
59870 }
59871
59872
59873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59874   int jresult ;
59875   int result;
59876
59877   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59878   jresult = (int)result;
59879   return jresult;
59880 }
59881
59882
59883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59884   int jresult ;
59885   int result;
59886
59887   result = (int)Dali::Toolkit::Button::Property::LABEL;
59888   jresult = (int)result;
59889   return jresult;
59890 }
59891
59892
59893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59894   int jresult ;
59895   int result;
59896
59897   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59898   jresult = (int)result;
59899   return jresult;
59900 }
59901
59902
59903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59904   void * jresult ;
59905   Dali::Toolkit::Button::Property *result = 0 ;
59906
59907   {
59908     try {
59909       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59910     } catch (std::out_of_range& e) {
59911       {
59912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59913       };
59914     } catch (std::exception& e) {
59915       {
59916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (...) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59921       };
59922     }
59923   }
59924   jresult = (void *)result;
59925   return jresult;
59926 }
59927
59928
59929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59930   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59931
59932   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59933   {
59934     try {
59935       delete arg1;
59936     } catch (std::out_of_range& e) {
59937       {
59938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59939       };
59940     } catch (std::exception& e) {
59941       {
59942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59943       };
59944     } catch (...) {
59945       {
59946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59947       };
59948     }
59949   }
59950 }
59951
59952
59953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59954   void * jresult ;
59955   Dali::Toolkit::Button *result = 0 ;
59956
59957   {
59958     try {
59959       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (...) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59971       };
59972     }
59973   }
59974   jresult = (void *)result;
59975   return jresult;
59976 }
59977
59978
59979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
59980   void * jresult ;
59981   Dali::Toolkit::Button *arg1 = 0 ;
59982   Dali::Toolkit::Button *result = 0 ;
59983
59984   arg1 = (Dali::Toolkit::Button *)jarg1;
59985   if (!arg1) {
59986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
59987     return 0;
59988   }
59989   {
59990     try {
59991       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
59992     } catch (std::out_of_range& e) {
59993       {
59994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59995       };
59996     } catch (std::exception& e) {
59997       {
59998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59999       };
60000     } catch (...) {
60001       {
60002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60003       };
60004     }
60005   }
60006   jresult = (void *)result;
60007   return jresult;
60008 }
60009
60010
60011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60012   void * jresult ;
60013   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60014   Dali::Toolkit::Button *arg2 = 0 ;
60015   Dali::Toolkit::Button *result = 0 ;
60016
60017   arg1 = (Dali::Toolkit::Button *)jarg1;
60018   arg2 = (Dali::Toolkit::Button *)jarg2;
60019   if (!arg2) {
60020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60021     return 0;
60022   }
60023   {
60024     try {
60025       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60026     } catch (std::out_of_range& e) {
60027       {
60028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (std::exception& e) {
60031       {
60032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040   jresult = (void *)result;
60041   return jresult;
60042 }
60043
60044
60045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60046   void * jresult ;
60047   Dali::BaseHandle arg1 ;
60048   Dali::BaseHandle *argp1 ;
60049   Dali::Toolkit::Button result;
60050
60051   argp1 = (Dali::BaseHandle *)jarg1;
60052   if (!argp1) {
60053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60054     return 0;
60055   }
60056   arg1 = *argp1;
60057   {
60058     try {
60059       result = Dali::Toolkit::Button::DownCast(arg1);
60060     } catch (std::out_of_range& e) {
60061       {
60062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60063       };
60064     } catch (std::exception& e) {
60065       {
60066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60067       };
60068     } catch (...) {
60069       {
60070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60071       };
60072     }
60073   }
60074   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60075   return jresult;
60076 }
60077
60078
60079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60080   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60081
60082   arg1 = (Dali::Toolkit::Button *)jarg1;
60083   {
60084     try {
60085       delete arg1;
60086     } catch (std::out_of_range& e) {
60087       {
60088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60089       };
60090     } catch (std::exception& e) {
60091       {
60092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60093       };
60094     } catch (...) {
60095       {
60096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60097       };
60098     }
60099   }
60100 }
60101
60102
60103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60104   unsigned int jresult ;
60105   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60106   bool result;
60107
60108   arg1 = (Dali::Toolkit::Button *)jarg1;
60109   {
60110     try {
60111       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60112     } catch (std::out_of_range& e) {
60113       {
60114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60115       };
60116     } catch (std::exception& e) {
60117       {
60118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60119       };
60120     } catch (...) {
60121       {
60122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60123       };
60124     }
60125   }
60126   jresult = result;
60127   return jresult;
60128 }
60129
60130
60131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60132   unsigned int jresult ;
60133   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60134   bool result;
60135
60136   arg1 = (Dali::Toolkit::Button *)jarg1;
60137   {
60138     try {
60139       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60140     } catch (std::out_of_range& e) {
60141       {
60142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60143       };
60144     } catch (std::exception& e) {
60145       {
60146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60147       };
60148     } catch (...) {
60149       {
60150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60151       };
60152     }
60153   }
60154   jresult = result;
60155   return jresult;
60156 }
60157
60158
60159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60160   float jresult ;
60161   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60162   float result;
60163
60164   arg1 = (Dali::Toolkit::Button *)jarg1;
60165   {
60166     try {
60167       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60168     } catch (std::out_of_range& e) {
60169       {
60170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60171       };
60172     } catch (std::exception& e) {
60173       {
60174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (...) {
60177       {
60178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60179       };
60180     }
60181   }
60182   jresult = result;
60183   return jresult;
60184 }
60185
60186
60187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60188   float jresult ;
60189   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60190   float result;
60191
60192   arg1 = (Dali::Toolkit::Button *)jarg1;
60193   {
60194     try {
60195       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60196     } catch (std::out_of_range& e) {
60197       {
60198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60199       };
60200     } catch (std::exception& e) {
60201       {
60202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60203       };
60204     } catch (...) {
60205       {
60206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60207       };
60208     }
60209   }
60210   jresult = result;
60211   return jresult;
60212 }
60213
60214
60215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60216   unsigned int jresult ;
60217   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60218   bool result;
60219
60220   arg1 = (Dali::Toolkit::Button *)jarg1;
60221   {
60222     try {
60223       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60224     } catch (std::out_of_range& e) {
60225       {
60226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60227       };
60228     } catch (std::exception& e) {
60229       {
60230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60231       };
60232     } catch (...) {
60233       {
60234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60235       };
60236     }
60237   }
60238   jresult = result;
60239   return jresult;
60240 }
60241
60242
60243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60244   unsigned int jresult ;
60245   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60246   bool result;
60247
60248   arg1 = (Dali::Toolkit::Button *)jarg1;
60249   {
60250     try {
60251       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60252     } catch (std::out_of_range& e) {
60253       {
60254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (std::exception& e) {
60257       {
60258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266   jresult = result;
60267   return jresult;
60268 }
60269
60270
60271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60272   float jresult ;
60273   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60274   float result;
60275
60276   arg1 = (Dali::Toolkit::Button *)jarg1;
60277   {
60278     try {
60279       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60280     } catch (std::out_of_range& e) {
60281       {
60282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (std::exception& e) {
60285       {
60286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60287       };
60288     } catch (...) {
60289       {
60290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60291       };
60292     }
60293   }
60294   jresult = result;
60295   return jresult;
60296 }
60297
60298
60299 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60300   char * jresult ;
60301   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60302   std::string result;
60303
60304   arg1 = (Dali::Toolkit::Button *)jarg1;
60305   {
60306     try {
60307       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60308     } catch (std::out_of_range& e) {
60309       {
60310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60311       };
60312     } catch (std::exception& e) {
60313       {
60314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60315       };
60316     } catch (...) {
60317       {
60318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60319       };
60320     }
60321   }
60322   jresult = SWIG_csharp_string_callback((&result)->c_str());
60323   return jresult;
60324 }
60325
60326
60327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60328   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60329   Dali::Actor arg2 ;
60330   Dali::Actor *argp2 ;
60331
60332   arg1 = (Dali::Toolkit::Button *)jarg1;
60333   argp2 = (Dali::Actor *)jarg2;
60334   if (!argp2) {
60335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60336     return ;
60337   }
60338   arg2 = *argp2;
60339   {
60340     try {
60341       (arg1)->SetLabel(arg2);
60342     } catch (std::out_of_range& e) {
60343       {
60344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60345       };
60346     } catch (std::exception& e) {
60347       {
60348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60349       };
60350     } catch (...) {
60351       {
60352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60353       };
60354     }
60355   }
60356 }
60357
60358
60359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60360   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60361   Dali::Image arg2 ;
60362   Dali::Image *argp2 ;
60363
60364   arg1 = (Dali::Toolkit::Button *)jarg1;
60365   argp2 = (Dali::Image *)jarg2;
60366   if (!argp2) {
60367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60368     return ;
60369   }
60370   arg2 = *argp2;
60371   {
60372     try {
60373       (arg1)->SetButtonImage(arg2);
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60385       };
60386     }
60387   }
60388 }
60389
60390
60391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60392   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60393   Dali::Image arg2 ;
60394   Dali::Image *argp2 ;
60395
60396   arg1 = (Dali::Toolkit::Button *)jarg1;
60397   argp2 = (Dali::Image *)jarg2;
60398   if (!argp2) {
60399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60400     return ;
60401   }
60402   arg2 = *argp2;
60403   {
60404     try {
60405       (arg1)->SetSelectedImage(arg2);
60406     } catch (std::out_of_range& e) {
60407       {
60408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60409       };
60410     } catch (std::exception& e) {
60411       {
60412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60413       };
60414     } catch (...) {
60415       {
60416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60417       };
60418     }
60419   }
60420 }
60421
60422
60423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60424   void * jresult ;
60425   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60426   Dali::Actor result;
60427
60428   arg1 = (Dali::Toolkit::Button *)jarg1;
60429   {
60430     try {
60431       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60432     } catch (std::out_of_range& e) {
60433       {
60434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (std::exception& e) {
60437       {
60438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60439       };
60440     } catch (...) {
60441       {
60442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60443       };
60444     }
60445   }
60446   jresult = new Dali::Actor((const Dali::Actor &)result);
60447   return jresult;
60448 }
60449
60450
60451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60452   void * jresult ;
60453   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60454   Dali::Actor result;
60455
60456   arg1 = (Dali::Toolkit::Button *)jarg1;
60457   {
60458     try {
60459       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60460     } catch (std::out_of_range& e) {
60461       {
60462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60463       };
60464     } catch (std::exception& e) {
60465       {
60466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60467       };
60468     } catch (...) {
60469       {
60470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60471       };
60472     }
60473   }
60474   jresult = new Dali::Actor((const Dali::Actor &)result);
60475   return jresult;
60476 }
60477
60478
60479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60480   void * jresult ;
60481   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60482   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60483
60484   arg1 = (Dali::Toolkit::Button *)jarg1;
60485   {
60486     try {
60487       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60488     } catch (std::out_of_range& e) {
60489       {
60490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60491       };
60492     } catch (std::exception& e) {
60493       {
60494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (...) {
60497       {
60498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60499       };
60500     }
60501   }
60502   jresult = (void *)result;
60503   return jresult;
60504 }
60505
60506
60507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60508   void * jresult ;
60509   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60510   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60511
60512   arg1 = (Dali::Toolkit::Button *)jarg1;
60513   {
60514     try {
60515       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (...) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60527       };
60528     }
60529   }
60530   jresult = (void *)result;
60531   return jresult;
60532 }
60533
60534
60535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60536   void * jresult ;
60537   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60538   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60539
60540   arg1 = (Dali::Toolkit::Button *)jarg1;
60541   {
60542     try {
60543       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60544     } catch (std::out_of_range& e) {
60545       {
60546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (std::exception& e) {
60549       {
60550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60551       };
60552     } catch (...) {
60553       {
60554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60555       };
60556     }
60557   }
60558   jresult = (void *)result;
60559   return jresult;
60560 }
60561
60562
60563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60564   void * jresult ;
60565   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60566   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60567
60568   arg1 = (Dali::Toolkit::Button *)jarg1;
60569   {
60570     try {
60571       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60572     } catch (std::out_of_range& e) {
60573       {
60574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60575       };
60576     } catch (std::exception& e) {
60577       {
60578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (...) {
60581       {
60582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60583       };
60584     }
60585   }
60586   jresult = (void *)result;
60587   return jresult;
60588 }
60589
60590
60591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60592   void * jresult ;
60593   Dali::Toolkit::CheckBoxButton *result = 0 ;
60594
60595   {
60596     try {
60597       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
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_new_CheckBoxButton__SWIG_1(void * jarg1) {
60618   void * jresult ;
60619   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60620   Dali::Toolkit::CheckBoxButton *result = 0 ;
60621
60622   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60623   if (!arg1) {
60624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60625     return 0;
60626   }
60627   {
60628     try {
60629       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60630     } catch (std::out_of_range& e) {
60631       {
60632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60633       };
60634     } catch (std::exception& e) {
60635       {
60636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60637       };
60638     } catch (...) {
60639       {
60640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60641       };
60642     }
60643   }
60644   jresult = (void *)result;
60645   return jresult;
60646 }
60647
60648
60649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60650   void * jresult ;
60651   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60652   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60653   Dali::Toolkit::CheckBoxButton *result = 0 ;
60654
60655   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60656   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60657   if (!arg2) {
60658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60659     return 0;
60660   }
60661   {
60662     try {
60663       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60664     } catch (std::out_of_range& e) {
60665       {
60666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60667       };
60668     } catch (std::exception& e) {
60669       {
60670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60671       };
60672     } catch (...) {
60673       {
60674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60675       };
60676     }
60677   }
60678   jresult = (void *)result;
60679   return jresult;
60680 }
60681
60682
60683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60684   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60685
60686   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60687   {
60688     try {
60689       delete arg1;
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60701       };
60702     }
60703   }
60704 }
60705
60706
60707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60708   void * jresult ;
60709   Dali::Toolkit::CheckBoxButton result;
60710
60711   {
60712     try {
60713       result = Dali::Toolkit::CheckBoxButton::New();
60714     } catch (std::out_of_range& e) {
60715       {
60716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60717       };
60718     } catch (std::exception& e) {
60719       {
60720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60721       };
60722     } catch (...) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60725       };
60726     }
60727   }
60728   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60729   return jresult;
60730 }
60731
60732
60733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60734   void * jresult ;
60735   Dali::BaseHandle arg1 ;
60736   Dali::BaseHandle *argp1 ;
60737   Dali::Toolkit::CheckBoxButton result;
60738
60739   argp1 = (Dali::BaseHandle *)jarg1;
60740   if (!argp1) {
60741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60742     return 0;
60743   }
60744   arg1 = *argp1;
60745   {
60746     try {
60747       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60748     } catch (std::out_of_range& e) {
60749       {
60750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (std::exception& e) {
60753       {
60754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (...) {
60757       {
60758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60759       };
60760     }
60761   }
60762   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60763   return jresult;
60764 }
60765
60766
60767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60768   int jresult ;
60769   int result;
60770
60771   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60772   jresult = (int)result;
60773   return jresult;
60774 }
60775
60776
60777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60778   int jresult ;
60779   int result;
60780
60781   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60782   jresult = (int)result;
60783   return jresult;
60784 }
60785
60786
60787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60788   int jresult ;
60789   int result;
60790
60791   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60792   jresult = (int)result;
60793   return jresult;
60794 }
60795
60796
60797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60798   int jresult ;
60799   int result;
60800
60801   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60802   jresult = (int)result;
60803   return jresult;
60804 }
60805
60806
60807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60808   int jresult ;
60809   int result;
60810
60811   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60812   jresult = (int)result;
60813   return jresult;
60814 }
60815
60816
60817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60818   void * jresult ;
60819   Dali::Toolkit::PushButton::Property *result = 0 ;
60820
60821   {
60822     try {
60823       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (...) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60835       };
60836     }
60837   }
60838   jresult = (void *)result;
60839   return jresult;
60840 }
60841
60842
60843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60844   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60845
60846   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60847   {
60848     try {
60849       delete arg1;
60850     } catch (std::out_of_range& e) {
60851       {
60852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60853       };
60854     } catch (std::exception& e) {
60855       {
60856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60857       };
60858     } catch (...) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60861       };
60862     }
60863   }
60864 }
60865
60866
60867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60868   void * jresult ;
60869   Dali::Toolkit::PushButton *result = 0 ;
60870
60871   {
60872     try {
60873       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60874     } catch (std::out_of_range& e) {
60875       {
60876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60877       };
60878     } catch (std::exception& e) {
60879       {
60880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60881       };
60882     } catch (...) {
60883       {
60884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60885       };
60886     }
60887   }
60888   jresult = (void *)result;
60889   return jresult;
60890 }
60891
60892
60893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60894   void * jresult ;
60895   Dali::Toolkit::PushButton *arg1 = 0 ;
60896   Dali::Toolkit::PushButton *result = 0 ;
60897
60898   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60899   if (!arg1) {
60900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60901     return 0;
60902   }
60903   {
60904     try {
60905       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60906     } catch (std::out_of_range& e) {
60907       {
60908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60909       };
60910     } catch (std::exception& e) {
60911       {
60912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60913       };
60914     } catch (...) {
60915       {
60916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60917       };
60918     }
60919   }
60920   jresult = (void *)result;
60921   return jresult;
60922 }
60923
60924
60925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60926   void * jresult ;
60927   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60928   Dali::Toolkit::PushButton *arg2 = 0 ;
60929   Dali::Toolkit::PushButton *result = 0 ;
60930
60931   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60932   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60933   if (!arg2) {
60934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60935     return 0;
60936   }
60937   {
60938     try {
60939       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
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 = (void *)result;
60955   return jresult;
60956 }
60957
60958
60959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
60960   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60961
60962   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60963   {
60964     try {
60965       delete arg1;
60966     } catch (std::out_of_range& e) {
60967       {
60968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60969       };
60970     } catch (std::exception& e) {
60971       {
60972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60973       };
60974     } catch (...) {
60975       {
60976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60977       };
60978     }
60979   }
60980 }
60981
60982
60983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
60984   void * jresult ;
60985   Dali::Toolkit::PushButton result;
60986
60987   {
60988     try {
60989       result = Dali::Toolkit::PushButton::New();
60990     } catch (std::out_of_range& e) {
60991       {
60992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60993       };
60994     } catch (std::exception& e) {
60995       {
60996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60997       };
60998     } catch (...) {
60999       {
61000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61001       };
61002     }
61003   }
61004   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61005   return jresult;
61006 }
61007
61008
61009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61010   void * jresult ;
61011   Dali::BaseHandle arg1 ;
61012   Dali::BaseHandle *argp1 ;
61013   Dali::Toolkit::PushButton result;
61014
61015   argp1 = (Dali::BaseHandle *)jarg1;
61016   if (!argp1) {
61017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61018     return 0;
61019   }
61020   arg1 = *argp1;
61021   {
61022     try {
61023       result = Dali::Toolkit::PushButton::DownCast(arg1);
61024     } catch (std::out_of_range& e) {
61025       {
61026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (std::exception& e) {
61029       {
61030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61039   return jresult;
61040 }
61041
61042
61043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61044   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61045   Dali::Image arg2 ;
61046   Dali::Image *argp2 ;
61047
61048   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61049   argp2 = (Dali::Image *)jarg2;
61050   if (!argp2) {
61051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61052     return ;
61053   }
61054   arg2 = *argp2;
61055   {
61056     try {
61057       (arg1)->SetButtonImage(arg2);
61058     } catch (std::out_of_range& e) {
61059       {
61060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61061       };
61062     } catch (std::exception& e) {
61063       {
61064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61065       };
61066     } catch (...) {
61067       {
61068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61069       };
61070     }
61071   }
61072 }
61073
61074
61075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61076   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61077   Dali::Actor arg2 ;
61078   Dali::Actor *argp2 ;
61079
61080   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61081   argp2 = (Dali::Actor *)jarg2;
61082   if (!argp2) {
61083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61084     return ;
61085   }
61086   arg2 = *argp2;
61087   {
61088     try {
61089       (arg1)->SetButtonImage(arg2);
61090     } catch (std::out_of_range& e) {
61091       {
61092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61093       };
61094     } catch (std::exception& e) {
61095       {
61096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61097       };
61098     } catch (...) {
61099       {
61100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61101       };
61102     }
61103   }
61104 }
61105
61106
61107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61108   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61109   Dali::Actor arg2 ;
61110   Dali::Actor *argp2 ;
61111
61112   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61113   argp2 = (Dali::Actor *)jarg2;
61114   if (!argp2) {
61115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61116     return ;
61117   }
61118   arg2 = *argp2;
61119   {
61120     try {
61121       (arg1)->SetBackgroundImage(arg2);
61122     } catch (std::out_of_range& e) {
61123       {
61124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61125       };
61126     } catch (std::exception& e) {
61127       {
61128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61129       };
61130     } catch (...) {
61131       {
61132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61133       };
61134     }
61135   }
61136 }
61137
61138
61139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61140   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61141   Dali::Image arg2 ;
61142   Dali::Image *argp2 ;
61143
61144   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61145   argp2 = (Dali::Image *)jarg2;
61146   if (!argp2) {
61147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61148     return ;
61149   }
61150   arg2 = *argp2;
61151   {
61152     try {
61153       (arg1)->SetSelectedImage(arg2);
61154     } catch (std::out_of_range& e) {
61155       {
61156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61157       };
61158     } catch (std::exception& e) {
61159       {
61160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61161       };
61162     } catch (...) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61165       };
61166     }
61167   }
61168 }
61169
61170
61171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61172   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61173   Dali::Actor arg2 ;
61174   Dali::Actor *argp2 ;
61175
61176   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61177   argp2 = (Dali::Actor *)jarg2;
61178   if (!argp2) {
61179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61180     return ;
61181   }
61182   arg2 = *argp2;
61183   {
61184     try {
61185       (arg1)->SetSelectedImage(arg2);
61186     } catch (std::out_of_range& e) {
61187       {
61188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61189       };
61190     } catch (std::exception& e) {
61191       {
61192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61193       };
61194     } catch (...) {
61195       {
61196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61197       };
61198     }
61199   }
61200 }
61201
61202
61203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61204   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61205   Dali::Actor arg2 ;
61206   Dali::Actor *argp2 ;
61207
61208   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61209   argp2 = (Dali::Actor *)jarg2;
61210   if (!argp2) {
61211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61212     return ;
61213   }
61214   arg2 = *argp2;
61215   {
61216     try {
61217       (arg1)->SetSelectedBackgroundImage(arg2);
61218     } catch (std::out_of_range& e) {
61219       {
61220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61221       };
61222     } catch (std::exception& e) {
61223       {
61224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61225       };
61226     } catch (...) {
61227       {
61228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61229       };
61230     }
61231   }
61232 }
61233
61234
61235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61236   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61237   Dali::Actor arg2 ;
61238   Dali::Actor *argp2 ;
61239
61240   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61241   argp2 = (Dali::Actor *)jarg2;
61242   if (!argp2) {
61243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61244     return ;
61245   }
61246   arg2 = *argp2;
61247   {
61248     try {
61249       (arg1)->SetDisabledBackgroundImage(arg2);
61250     } catch (std::out_of_range& e) {
61251       {
61252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61253       };
61254     } catch (std::exception& e) {
61255       {
61256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61257       };
61258     } catch (...) {
61259       {
61260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61261       };
61262     }
61263   }
61264 }
61265
61266
61267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61268   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61269   Dali::Actor arg2 ;
61270   Dali::Actor *argp2 ;
61271
61272   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61273   argp2 = (Dali::Actor *)jarg2;
61274   if (!argp2) {
61275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61276     return ;
61277   }
61278   arg2 = *argp2;
61279   {
61280     try {
61281       (arg1)->SetDisabledImage(arg2);
61282     } catch (std::out_of_range& e) {
61283       {
61284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61285       };
61286     } catch (std::exception& e) {
61287       {
61288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61289       };
61290     } catch (...) {
61291       {
61292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61293       };
61294     }
61295   }
61296 }
61297
61298
61299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61300   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61301   Dali::Actor arg2 ;
61302   Dali::Actor *argp2 ;
61303
61304   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61305   argp2 = (Dali::Actor *)jarg2;
61306   if (!argp2) {
61307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61308     return ;
61309   }
61310   arg2 = *argp2;
61311   {
61312     try {
61313       (arg1)->SetDisabledSelectedImage(arg2);
61314     } catch (std::out_of_range& e) {
61315       {
61316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61317       };
61318     } catch (std::exception& e) {
61319       {
61320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61325       };
61326     }
61327   }
61328 }
61329
61330
61331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61332   void * jresult ;
61333   Dali::Toolkit::RadioButton *result = 0 ;
61334
61335   {
61336     try {
61337       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61345       };
61346     } catch (...) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61349       };
61350     }
61351   }
61352   jresult = (void *)result;
61353   return jresult;
61354 }
61355
61356
61357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61358   void * jresult ;
61359   Dali::Toolkit::RadioButton *arg1 = 0 ;
61360   Dali::Toolkit::RadioButton *result = 0 ;
61361
61362   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61363   if (!arg1) {
61364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61365     return 0;
61366   }
61367   {
61368     try {
61369       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61370     } catch (std::out_of_range& e) {
61371       {
61372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61373       };
61374     } catch (std::exception& e) {
61375       {
61376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61377       };
61378     } catch (...) {
61379       {
61380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61381       };
61382     }
61383   }
61384   jresult = (void *)result;
61385   return jresult;
61386 }
61387
61388
61389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61390   void * jresult ;
61391   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61392   Dali::Toolkit::RadioButton *arg2 = 0 ;
61393   Dali::Toolkit::RadioButton *result = 0 ;
61394
61395   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61396   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61397   if (!arg2) {
61398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61399     return 0;
61400   }
61401   {
61402     try {
61403       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61404     } catch (std::out_of_range& e) {
61405       {
61406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61407       };
61408     } catch (std::exception& e) {
61409       {
61410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61411       };
61412     } catch (...) {
61413       {
61414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61415       };
61416     }
61417   }
61418   jresult = (void *)result;
61419   return jresult;
61420 }
61421
61422
61423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61424   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61425
61426   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61427   {
61428     try {
61429       delete arg1;
61430     } catch (std::out_of_range& e) {
61431       {
61432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61433       };
61434     } catch (std::exception& e) {
61435       {
61436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61437       };
61438     } catch (...) {
61439       {
61440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61441       };
61442     }
61443   }
61444 }
61445
61446
61447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61448   void * jresult ;
61449   Dali::Toolkit::RadioButton result;
61450
61451   {
61452     try {
61453       result = Dali::Toolkit::RadioButton::New();
61454     } catch (std::out_of_range& e) {
61455       {
61456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (std::exception& e) {
61459       {
61460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (...) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61465       };
61466     }
61467   }
61468   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61469   return jresult;
61470 }
61471
61472
61473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61474   void * jresult ;
61475   std::string *arg1 = 0 ;
61476   Dali::Toolkit::RadioButton result;
61477
61478   if (!jarg1) {
61479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61480     return 0;
61481   }
61482   std::string arg1_str(jarg1);
61483   arg1 = &arg1_str;
61484   {
61485     try {
61486       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61487     } catch (std::out_of_range& e) {
61488       {
61489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61490       };
61491     } catch (std::exception& e) {
61492       {
61493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (...) {
61496       {
61497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61498       };
61499     }
61500   }
61501   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61502
61503   //argout typemap for const std::string&
61504
61505   return jresult;
61506 }
61507
61508
61509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61510   void * jresult ;
61511   Dali::BaseHandle arg1 ;
61512   Dali::BaseHandle *argp1 ;
61513   Dali::Toolkit::RadioButton result;
61514
61515   argp1 = (Dali::BaseHandle *)jarg1;
61516   if (!argp1) {
61517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61518     return 0;
61519   }
61520   arg1 = *argp1;
61521   {
61522     try {
61523       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61524     } catch (std::out_of_range& e) {
61525       {
61526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61527       };
61528     } catch (std::exception& e) {
61529       {
61530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61531       };
61532     } catch (...) {
61533       {
61534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61535       };
61536     }
61537   }
61538   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61539   return jresult;
61540 }
61541
61542
61543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61544   int jresult ;
61545   int result;
61546
61547   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61548   jresult = (int)result;
61549   return jresult;
61550 }
61551
61552
61553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61554   int jresult ;
61555   int result;
61556
61557   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61558   jresult = (int)result;
61559   return jresult;
61560 }
61561
61562
61563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61564   int jresult ;
61565   int result;
61566
61567   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61568   jresult = (int)result;
61569   return jresult;
61570 }
61571
61572
61573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61574   int jresult ;
61575   int result;
61576
61577   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61578   jresult = (int)result;
61579   return jresult;
61580 }
61581
61582
61583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61584   int jresult ;
61585   int result;
61586
61587   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61588   jresult = (int)result;
61589   return jresult;
61590 }
61591
61592
61593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61594   int jresult ;
61595   int result;
61596
61597   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61598   jresult = (int)result;
61599   return jresult;
61600 }
61601
61602
61603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61604   void * jresult ;
61605   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61606
61607   {
61608     try {
61609       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61610     } catch (std::out_of_range& e) {
61611       {
61612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61613       };
61614     } catch (std::exception& e) {
61615       {
61616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61617       };
61618     } catch (...) {
61619       {
61620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61621       };
61622     }
61623   }
61624   jresult = (void *)result;
61625   return jresult;
61626 }
61627
61628
61629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61630   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61631
61632   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61633   {
61634     try {
61635       delete arg1;
61636     } catch (std::out_of_range& e) {
61637       {
61638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61639       };
61640     } catch (std::exception& e) {
61641       {
61642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61643       };
61644     } catch (...) {
61645       {
61646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61647       };
61648     }
61649   }
61650 }
61651
61652
61653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61654   int jresult ;
61655   int result;
61656
61657   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61658   jresult = (int)result;
61659   return jresult;
61660 }
61661
61662
61663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61664   int jresult ;
61665   int result;
61666
61667   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61668   jresult = (int)result;
61669   return jresult;
61670 }
61671
61672
61673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61674   int jresult ;
61675   int result;
61676
61677   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61678   jresult = (int)result;
61679   return jresult;
61680 }
61681
61682
61683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61684   void * jresult ;
61685   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61686
61687   {
61688     try {
61689       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61690     } catch (std::out_of_range& e) {
61691       {
61692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61693       };
61694     } catch (std::exception& e) {
61695       {
61696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (...) {
61699       {
61700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61701       };
61702     }
61703   }
61704   jresult = (void *)result;
61705   return jresult;
61706 }
61707
61708
61709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61710   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61711
61712   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61713   {
61714     try {
61715       delete arg1;
61716     } catch (std::out_of_range& e) {
61717       {
61718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61719       };
61720     } catch (std::exception& e) {
61721       {
61722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61723       };
61724     } catch (...) {
61725       {
61726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61727       };
61728     }
61729   }
61730 }
61731
61732
61733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61734   void * jresult ;
61735   Dali::Toolkit::FlexContainer *result = 0 ;
61736
61737   {
61738     try {
61739       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61740     } catch (std::out_of_range& e) {
61741       {
61742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61743       };
61744     } catch (std::exception& e) {
61745       {
61746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61751       };
61752     }
61753   }
61754   jresult = (void *)result;
61755   return jresult;
61756 }
61757
61758
61759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61760   void * jresult ;
61761   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61762   Dali::Toolkit::FlexContainer *result = 0 ;
61763
61764   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61765   if (!arg1) {
61766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61767     return 0;
61768   }
61769   {
61770     try {
61771       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61772     } catch (std::out_of_range& e) {
61773       {
61774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61775       };
61776     } catch (std::exception& e) {
61777       {
61778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61779       };
61780     } catch (...) {
61781       {
61782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61783       };
61784     }
61785   }
61786   jresult = (void *)result;
61787   return jresult;
61788 }
61789
61790
61791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61792   void * jresult ;
61793   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61794   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61795   Dali::Toolkit::FlexContainer *result = 0 ;
61796
61797   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61798   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61799   if (!arg2) {
61800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61801     return 0;
61802   }
61803   {
61804     try {
61805       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61806     } catch (std::out_of_range& e) {
61807       {
61808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61809       };
61810     } catch (std::exception& e) {
61811       {
61812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61813       };
61814     } catch (...) {
61815       {
61816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61817       };
61818     }
61819   }
61820   jresult = (void *)result;
61821   return jresult;
61822 }
61823
61824
61825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61826   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61827
61828   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61829   {
61830     try {
61831       delete arg1;
61832     } catch (std::out_of_range& e) {
61833       {
61834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61835       };
61836     } catch (std::exception& e) {
61837       {
61838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61839       };
61840     } catch (...) {
61841       {
61842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61843       };
61844     }
61845   }
61846 }
61847
61848
61849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61850   void * jresult ;
61851   Dali::Toolkit::FlexContainer result;
61852
61853   {
61854     try {
61855       result = Dali::Toolkit::FlexContainer::New();
61856     } catch (std::out_of_range& e) {
61857       {
61858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61859       };
61860     } catch (std::exception& e) {
61861       {
61862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61867       };
61868     }
61869   }
61870   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61871   return jresult;
61872 }
61873
61874
61875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61876   void * jresult ;
61877   Dali::BaseHandle arg1 ;
61878   Dali::BaseHandle *argp1 ;
61879   Dali::Toolkit::FlexContainer result;
61880
61881   argp1 = (Dali::BaseHandle *)jarg1;
61882   if (!argp1) {
61883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61884     return 0;
61885   }
61886   arg1 = *argp1;
61887   {
61888     try {
61889       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (...) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61901       };
61902     }
61903   }
61904   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61905   return jresult;
61906 }
61907
61908
61909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61910   int jresult ;
61911   int result;
61912
61913   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61914   jresult = (int)result;
61915   return jresult;
61916 }
61917
61918
61919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61920   int jresult ;
61921   int result;
61922
61923   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61924   jresult = (int)result;
61925   return jresult;
61926 }
61927
61928
61929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61930   int jresult ;
61931   int result;
61932
61933   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61934   jresult = (int)result;
61935   return jresult;
61936 }
61937
61938
61939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61940   int jresult ;
61941   int result;
61942
61943   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61944   jresult = (int)result;
61945   return jresult;
61946 }
61947
61948
61949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61950   void * jresult ;
61951   Dali::Toolkit::ImageView::Property *result = 0 ;
61952
61953   {
61954     try {
61955       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
61956     } catch (std::out_of_range& e) {
61957       {
61958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61959       };
61960     } catch (std::exception& e) {
61961       {
61962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61963       };
61964     } catch (...) {
61965       {
61966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61967       };
61968     }
61969   }
61970   jresult = (void *)result;
61971   return jresult;
61972 }
61973
61974
61975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
61976   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
61977
61978   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
61979   {
61980     try {
61981       delete arg1;
61982     } catch (std::out_of_range& e) {
61983       {
61984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61985       };
61986     } catch (std::exception& e) {
61987       {
61988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61989       };
61990     } catch (...) {
61991       {
61992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61993       };
61994     }
61995   }
61996 }
61997
61998
61999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62000   void * jresult ;
62001   Dali::Toolkit::ImageView *result = 0 ;
62002
62003   {
62004     try {
62005       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62006     } catch (std::out_of_range& e) {
62007       {
62008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62009       };
62010     } catch (std::exception& e) {
62011       {
62012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62013       };
62014     } catch (...) {
62015       {
62016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62017       };
62018     }
62019   }
62020   jresult = (void *)result;
62021   return jresult;
62022 }
62023
62024
62025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62026   void * jresult ;
62027   Dali::Toolkit::ImageView result;
62028
62029   {
62030     try {
62031       result = Dali::Toolkit::ImageView::New();
62032     } catch (std::out_of_range& e) {
62033       {
62034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62035       };
62036     } catch (std::exception& e) {
62037       {
62038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62039       };
62040     } catch (...) {
62041       {
62042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62043       };
62044     }
62045   }
62046   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62047   return jresult;
62048 }
62049
62050
62051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62052   void * jresult ;
62053   Dali::Image arg1 ;
62054   Dali::Image *argp1 ;
62055   Dali::Toolkit::ImageView result;
62056
62057   argp1 = (Dali::Image *)jarg1;
62058   if (!argp1) {
62059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62060     return 0;
62061   }
62062   arg1 = *argp1;
62063   {
62064     try {
62065       result = Dali::Toolkit::ImageView::New(arg1);
62066     } catch (std::out_of_range& e) {
62067       {
62068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62069       };
62070     } catch (std::exception& e) {
62071       {
62072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62073       };
62074     } catch (...) {
62075       {
62076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62077       };
62078     }
62079   }
62080   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62081   return jresult;
62082 }
62083
62084
62085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62086   void * jresult ;
62087   std::string *arg1 = 0 ;
62088   Dali::Toolkit::ImageView result;
62089
62090   if (!jarg1) {
62091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62092     return 0;
62093   }
62094   std::string arg1_str(jarg1);
62095   arg1 = &arg1_str;
62096   {
62097     try {
62098       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62099     } catch (std::out_of_range& e) {
62100       {
62101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (std::exception& e) {
62104       {
62105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62110       };
62111     }
62112   }
62113   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62114
62115   //argout typemap for const std::string&
62116
62117   return jresult;
62118 }
62119
62120
62121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62122   void * jresult ;
62123   std::string *arg1 = 0 ;
62124   Dali::ImageDimensions arg2 ;
62125   Dali::ImageDimensions *argp2 ;
62126   Dali::Toolkit::ImageView result;
62127
62128   if (!jarg1) {
62129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62130     return 0;
62131   }
62132   std::string arg1_str(jarg1);
62133   arg1 = &arg1_str;
62134   argp2 = (Dali::ImageDimensions *)jarg2;
62135   if (!argp2) {
62136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62137     return 0;
62138   }
62139   arg2 = *argp2;
62140   {
62141     try {
62142       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62143     } catch (std::out_of_range& e) {
62144       {
62145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (std::exception& e) {
62148       {
62149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (...) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62154       };
62155     }
62156   }
62157   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62158
62159   //argout typemap for const std::string&
62160
62161   return jresult;
62162 }
62163
62164
62165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62166   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62167
62168   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62169   {
62170     try {
62171       delete arg1;
62172     } catch (std::out_of_range& e) {
62173       {
62174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62175       };
62176     } catch (std::exception& e) {
62177       {
62178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62179       };
62180     } catch (...) {
62181       {
62182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62183       };
62184     }
62185   }
62186 }
62187
62188
62189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62190   void * jresult ;
62191   Dali::Toolkit::ImageView *arg1 = 0 ;
62192   Dali::Toolkit::ImageView *result = 0 ;
62193
62194   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62195   if (!arg1) {
62196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62197     return 0;
62198   }
62199   {
62200     try {
62201       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62202     } catch (std::out_of_range& e) {
62203       {
62204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62205       };
62206     } catch (std::exception& e) {
62207       {
62208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62209       };
62210     } catch (...) {
62211       {
62212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62213       };
62214     }
62215   }
62216   jresult = (void *)result;
62217   return jresult;
62218 }
62219
62220
62221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62222   void * jresult ;
62223   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62224   Dali::Toolkit::ImageView *arg2 = 0 ;
62225   Dali::Toolkit::ImageView *result = 0 ;
62226
62227   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62228   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62229   if (!arg2) {
62230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62231     return 0;
62232   }
62233   {
62234     try {
62235       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62236     } catch (std::out_of_range& e) {
62237       {
62238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62239       };
62240     } catch (std::exception& e) {
62241       {
62242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62243       };
62244     } catch (...) {
62245       {
62246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62247       };
62248     }
62249   }
62250   jresult = (void *)result;
62251   return jresult;
62252 }
62253
62254
62255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62256   void * jresult ;
62257   Dali::BaseHandle arg1 ;
62258   Dali::BaseHandle *argp1 ;
62259   Dali::Toolkit::ImageView result;
62260
62261   argp1 = (Dali::BaseHandle *)jarg1;
62262   if (!argp1) {
62263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62264     return 0;
62265   }
62266   arg1 = *argp1;
62267   {
62268     try {
62269       result = Dali::Toolkit::ImageView::DownCast(arg1);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62281       };
62282     }
62283   }
62284   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62285   return jresult;
62286 }
62287
62288
62289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62290   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62291   Dali::Image arg2 ;
62292   Dali::Image *argp2 ;
62293
62294   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62295   argp2 = (Dali::Image *)jarg2;
62296   if (!argp2) {
62297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62298     return ;
62299   }
62300   arg2 = *argp2;
62301   {
62302     try {
62303       (arg1)->SetImage(arg2);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62315       };
62316     }
62317   }
62318 }
62319
62320
62321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62322   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62323   std::string *arg2 = 0 ;
62324
62325   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62326   if (!jarg2) {
62327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62328     return ;
62329   }
62330   std::string arg2_str(jarg2);
62331   arg2 = &arg2_str;
62332   {
62333     try {
62334       (arg1)->SetImage((std::string const &)*arg2);
62335     } catch (std::out_of_range& e) {
62336       {
62337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62338       };
62339     } catch (std::exception& e) {
62340       {
62341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62342       };
62343     } catch (...) {
62344       {
62345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62346       };
62347     }
62348   }
62349
62350   //argout typemap for const std::string&
62351
62352 }
62353
62354
62355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62356   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62357   std::string *arg2 = 0 ;
62358   Dali::ImageDimensions arg3 ;
62359   Dali::ImageDimensions *argp3 ;
62360
62361   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62362   if (!jarg2) {
62363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62364     return ;
62365   }
62366   std::string arg2_str(jarg2);
62367   arg2 = &arg2_str;
62368   argp3 = (Dali::ImageDimensions *)jarg3;
62369   if (!argp3) {
62370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62371     return ;
62372   }
62373   arg3 = *argp3;
62374   {
62375     try {
62376       (arg1)->SetImage((std::string const &)*arg2,arg3);
62377     } catch (std::out_of_range& e) {
62378       {
62379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62380       };
62381     } catch (std::exception& e) {
62382       {
62383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62384       };
62385     } catch (...) {
62386       {
62387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62388       };
62389     }
62390   }
62391
62392   //argout typemap for const std::string&
62393
62394 }
62395
62396
62397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62398   void * jresult ;
62399   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62400   Dali::Image result;
62401
62402   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62403   {
62404     try {
62405       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62413       };
62414     } catch (...) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62417       };
62418     }
62419   }
62420   jresult = new Dali::Image((const Dali::Image &)result);
62421   return jresult;
62422 }
62423
62424
62425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62426   int jresult ;
62427   int result;
62428
62429   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62430   jresult = (int)result;
62431   return jresult;
62432 }
62433
62434
62435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62436   int jresult ;
62437   int result;
62438
62439   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62440   jresult = (int)result;
62441   return jresult;
62442 }
62443
62444
62445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62446   int jresult ;
62447   int result;
62448
62449   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62450   jresult = (int)result;
62451   return jresult;
62452 }
62453
62454
62455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62456   int jresult ;
62457   int result;
62458
62459   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62460   jresult = (int)result;
62461   return jresult;
62462 }
62463
62464
62465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62466   int jresult ;
62467   int result;
62468
62469   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62470   jresult = (int)result;
62471   return jresult;
62472 }
62473
62474
62475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62476   int jresult ;
62477   int result;
62478
62479   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62480   jresult = (int)result;
62481   return jresult;
62482 }
62483
62484
62485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62486   int jresult ;
62487   int result;
62488
62489   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62490   jresult = (int)result;
62491   return jresult;
62492 }
62493
62494
62495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62496   int jresult ;
62497   int result;
62498
62499   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62500   jresult = (int)result;
62501   return jresult;
62502 }
62503
62504
62505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62506   void * jresult ;
62507   Dali::Toolkit::Model3dView::Property *result = 0 ;
62508
62509   {
62510     try {
62511       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62512     } catch (std::out_of_range& e) {
62513       {
62514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62515       };
62516     } catch (std::exception& e) {
62517       {
62518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62519       };
62520     } catch (...) {
62521       {
62522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62523       };
62524     }
62525   }
62526   jresult = (void *)result;
62527   return jresult;
62528 }
62529
62530
62531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62532   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62533
62534   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62535   {
62536     try {
62537       delete arg1;
62538     } catch (std::out_of_range& e) {
62539       {
62540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62541       };
62542     } catch (std::exception& e) {
62543       {
62544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62545       };
62546     } catch (...) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62549       };
62550     }
62551   }
62552 }
62553
62554
62555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62556   void * jresult ;
62557   Dali::Toolkit::Model3dView result;
62558
62559   {
62560     try {
62561       result = Dali::Toolkit::Model3dView::New();
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 = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62582   void * jresult ;
62583   std::string *arg1 = 0 ;
62584   std::string *arg2 = 0 ;
62585   std::string *arg3 = 0 ;
62586   Dali::Toolkit::Model3dView result;
62587
62588   if (!jarg1) {
62589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62590     return 0;
62591   }
62592   std::string arg1_str(jarg1);
62593   arg1 = &arg1_str;
62594   if (!jarg2) {
62595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62596     return 0;
62597   }
62598   std::string arg2_str(jarg2);
62599   arg2 = &arg2_str;
62600   if (!jarg3) {
62601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62602     return 0;
62603   }
62604   std::string arg3_str(jarg3);
62605   arg3 = &arg3_str;
62606   {
62607     try {
62608       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62609     } catch (std::out_of_range& e) {
62610       {
62611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62612       };
62613     } catch (std::exception& e) {
62614       {
62615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62616       };
62617     } catch (...) {
62618       {
62619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62620       };
62621     }
62622   }
62623   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62624
62625   //argout typemap for const std::string&
62626
62627
62628   //argout typemap for const std::string&
62629
62630
62631   //argout typemap for const std::string&
62632
62633   return jresult;
62634 }
62635
62636
62637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62638   void * jresult ;
62639   Dali::Toolkit::Model3dView *result = 0 ;
62640
62641   {
62642     try {
62643       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62644     } catch (std::out_of_range& e) {
62645       {
62646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62647       };
62648     } catch (std::exception& e) {
62649       {
62650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62651       };
62652     } catch (...) {
62653       {
62654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62655       };
62656     }
62657   }
62658   jresult = (void *)result;
62659   return jresult;
62660 }
62661
62662
62663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62664   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62665
62666   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62667   {
62668     try {
62669       delete arg1;
62670     } catch (std::out_of_range& e) {
62671       {
62672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62673       };
62674     } catch (std::exception& e) {
62675       {
62676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62677       };
62678     } catch (...) {
62679       {
62680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62681       };
62682     }
62683   }
62684 }
62685
62686
62687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62688   void * jresult ;
62689   Dali::Toolkit::Model3dView *arg1 = 0 ;
62690   Dali::Toolkit::Model3dView *result = 0 ;
62691
62692   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62693   if (!arg1) {
62694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62695     return 0;
62696   }
62697   {
62698     try {
62699       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62700     } catch (std::out_of_range& e) {
62701       {
62702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62703       };
62704     } catch (std::exception& e) {
62705       {
62706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62707       };
62708     } catch (...) {
62709       {
62710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62711       };
62712     }
62713   }
62714   jresult = (void *)result;
62715   return jresult;
62716 }
62717
62718
62719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62720   void * jresult ;
62721   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62722   Dali::Toolkit::Model3dView *arg2 = 0 ;
62723   Dali::Toolkit::Model3dView *result = 0 ;
62724
62725   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62726   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62727   if (!arg2) {
62728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62729     return 0;
62730   }
62731   {
62732     try {
62733       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62734     } catch (std::out_of_range& e) {
62735       {
62736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62737       };
62738     } catch (std::exception& e) {
62739       {
62740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62741       };
62742     } catch (...) {
62743       {
62744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62745       };
62746     }
62747   }
62748   jresult = (void *)result;
62749   return jresult;
62750 }
62751
62752
62753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62754   void * jresult ;
62755   Dali::BaseHandle arg1 ;
62756   Dali::BaseHandle *argp1 ;
62757   Dali::Toolkit::Model3dView result;
62758
62759   argp1 = (Dali::BaseHandle *)jarg1;
62760   if (!argp1) {
62761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62762     return 0;
62763   }
62764   arg1 = *argp1;
62765   {
62766     try {
62767       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62768     } catch (std::out_of_range& e) {
62769       {
62770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62771       };
62772     } catch (std::exception& e) {
62773       {
62774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62779       };
62780     }
62781   }
62782   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62783   return jresult;
62784 }
62785
62786
62787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62788   int jresult ;
62789   int result;
62790
62791   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62792   jresult = (int)result;
62793   return jresult;
62794 }
62795
62796
62797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62798   int jresult ;
62799   int result;
62800
62801   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62802   jresult = (int)result;
62803   return jresult;
62804 }
62805
62806
62807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62808   int jresult ;
62809   int result;
62810
62811   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62812   jresult = (int)result;
62813   return jresult;
62814 }
62815
62816
62817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62818   int jresult ;
62819   int result;
62820
62821   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62822   jresult = (int)result;
62823   return jresult;
62824 }
62825
62826
62827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62828   int jresult ;
62829   int result;
62830
62831   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62832   jresult = (int)result;
62833   return jresult;
62834 }
62835
62836
62837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62838   int jresult ;
62839   int result;
62840
62841   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62842   jresult = (int)result;
62843   return jresult;
62844 }
62845
62846
62847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62848   int jresult ;
62849   int result;
62850
62851   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62852   jresult = (int)result;
62853   return jresult;
62854 }
62855
62856
62857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62858   int jresult ;
62859   int result;
62860
62861   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62862   jresult = (int)result;
62863   return jresult;
62864 }
62865
62866
62867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62868   int jresult ;
62869   int result;
62870
62871   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62872   jresult = (int)result;
62873   return jresult;
62874 }
62875
62876
62877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62878   void * jresult ;
62879   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62880
62881   {
62882     try {
62883       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
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_delete_ScrollBar_Property(void * jarg1) {
62904   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62905
62906   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62907   {
62908     try {
62909       delete arg1;
62910     } catch (std::out_of_range& e) {
62911       {
62912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62913       };
62914     } catch (std::exception& e) {
62915       {
62916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62917       };
62918     } catch (...) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62921       };
62922     }
62923   }
62924 }
62925
62926
62927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62928   void * jresult ;
62929   Dali::Toolkit::ScrollBar *result = 0 ;
62930
62931   {
62932     try {
62933       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62934     } catch (std::out_of_range& e) {
62935       {
62936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62937       };
62938     } catch (std::exception& e) {
62939       {
62940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (...) {
62943       {
62944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62945       };
62946     }
62947   }
62948   jresult = (void *)result;
62949   return jresult;
62950 }
62951
62952
62953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62954   void * jresult ;
62955   Dali::Toolkit::ScrollBar *arg1 = 0 ;
62956   Dali::Toolkit::ScrollBar *result = 0 ;
62957
62958   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62959   if (!arg1) {
62960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62961     return 0;
62962   }
62963   {
62964     try {
62965       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (...) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62977       };
62978     }
62979   }
62980   jresult = (void *)result;
62981   return jresult;
62982 }
62983
62984
62985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
62986   void * jresult ;
62987   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
62988   Dali::Toolkit::ScrollBar *arg2 = 0 ;
62989   Dali::Toolkit::ScrollBar *result = 0 ;
62990
62991   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62992   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
62993   if (!arg2) {
62994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62995     return 0;
62996   }
62997   {
62998     try {
62999       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63000     } catch (std::out_of_range& e) {
63001       {
63002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (std::exception& e) {
63005       {
63006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (...) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63011       };
63012     }
63013   }
63014   jresult = (void *)result;
63015   return jresult;
63016 }
63017
63018
63019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63020   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63021
63022   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63023   {
63024     try {
63025       delete arg1;
63026     } catch (std::out_of_range& e) {
63027       {
63028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63029       };
63030     } catch (std::exception& e) {
63031       {
63032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63033       };
63034     } catch (...) {
63035       {
63036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63037       };
63038     }
63039   }
63040 }
63041
63042
63043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63044   void * jresult ;
63045   Dali::Toolkit::ScrollBar::Direction arg1 ;
63046   Dali::Toolkit::ScrollBar result;
63047
63048   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63049   {
63050     try {
63051       result = Dali::Toolkit::ScrollBar::New(arg1);
63052     } catch (std::out_of_range& e) {
63053       {
63054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63055       };
63056     } catch (std::exception& e) {
63057       {
63058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63059       };
63060     } catch (...) {
63061       {
63062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63063       };
63064     }
63065   }
63066   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63067   return jresult;
63068 }
63069
63070
63071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63072   void * jresult ;
63073   Dali::Toolkit::ScrollBar result;
63074
63075   {
63076     try {
63077       result = Dali::Toolkit::ScrollBar::New();
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 = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63093   return jresult;
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63098   void * jresult ;
63099   Dali::BaseHandle arg1 ;
63100   Dali::BaseHandle *argp1 ;
63101   Dali::Toolkit::ScrollBar result;
63102
63103   argp1 = (Dali::BaseHandle *)jarg1;
63104   if (!argp1) {
63105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63106     return 0;
63107   }
63108   arg1 = *argp1;
63109   {
63110     try {
63111       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63112     } catch (std::out_of_range& e) {
63113       {
63114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63115       };
63116     } catch (std::exception& e) {
63117       {
63118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63119       };
63120     } catch (...) {
63121       {
63122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63123       };
63124     }
63125   }
63126   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63127   return jresult;
63128 }
63129
63130
63131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63132   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63133   Dali::Handle arg2 ;
63134   Dali::Property::Index arg3 ;
63135   Dali::Property::Index arg4 ;
63136   Dali::Property::Index arg5 ;
63137   Dali::Property::Index arg6 ;
63138   Dali::Handle *argp2 ;
63139
63140   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63141   argp2 = (Dali::Handle *)jarg2;
63142   if (!argp2) {
63143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63144     return ;
63145   }
63146   arg2 = *argp2;
63147   arg3 = (Dali::Property::Index)jarg3;
63148   arg4 = (Dali::Property::Index)jarg4;
63149   arg5 = (Dali::Property::Index)jarg5;
63150   arg6 = (Dali::Property::Index)jarg6;
63151   {
63152     try {
63153       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63154     } catch (std::out_of_range& e) {
63155       {
63156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63157       };
63158     } catch (std::exception& e) {
63159       {
63160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63161       };
63162     } catch (...) {
63163       {
63164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63165       };
63166     }
63167   }
63168 }
63169
63170
63171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63172   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63173   Dali::Actor arg2 ;
63174   Dali::Actor *argp2 ;
63175
63176   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63177   argp2 = (Dali::Actor *)jarg2;
63178   if (!argp2) {
63179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63180     return ;
63181   }
63182   arg2 = *argp2;
63183   {
63184     try {
63185       (arg1)->SetScrollIndicator(arg2);
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63193       };
63194     } catch (...) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63197       };
63198     }
63199   }
63200 }
63201
63202
63203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63204   void * jresult ;
63205   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63206   Dali::Actor result;
63207
63208   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63209   {
63210     try {
63211       result = (arg1)->GetScrollIndicator();
63212     } catch (std::out_of_range& e) {
63213       {
63214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63215       };
63216     } catch (std::exception& e) {
63217       {
63218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63219       };
63220     } catch (...) {
63221       {
63222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63223       };
63224     }
63225   }
63226   jresult = new Dali::Actor((const Dali::Actor &)result);
63227   return jresult;
63228 }
63229
63230
63231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63232   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63233   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63234
63235   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63236   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63237   if (!arg2) {
63238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63239     return ;
63240   }
63241   {
63242     try {
63243       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63244     } catch (std::out_of_range& e) {
63245       {
63246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63247       };
63248     } catch (std::exception& e) {
63249       {
63250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63251       };
63252     } catch (...) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63255       };
63256     }
63257   }
63258 }
63259
63260
63261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63262   void * jresult ;
63263   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63264   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63265
63266   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63267   {
63268     try {
63269       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63270     } catch (std::out_of_range& e) {
63271       {
63272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63273       };
63274     } catch (std::exception& e) {
63275       {
63276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63277       };
63278     } catch (...) {
63279       {
63280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63281       };
63282     }
63283   }
63284   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63285   return jresult;
63286 }
63287
63288
63289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63290   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63291   Dali::Toolkit::ScrollBar::Direction arg2 ;
63292
63293   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63294   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63295   {
63296     try {
63297       (arg1)->SetScrollDirection(arg2);
63298     } catch (std::out_of_range& e) {
63299       {
63300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63301       };
63302     } catch (std::exception& e) {
63303       {
63304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63305       };
63306     } catch (...) {
63307       {
63308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63309       };
63310     }
63311   }
63312 }
63313
63314
63315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63316   int jresult ;
63317   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63318   Dali::Toolkit::ScrollBar::Direction result;
63319
63320   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63321   {
63322     try {
63323       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63324     } catch (std::out_of_range& e) {
63325       {
63326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63327       };
63328     } catch (std::exception& e) {
63329       {
63330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63331       };
63332     } catch (...) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63335       };
63336     }
63337   }
63338   jresult = (int)result;
63339   return jresult;
63340 }
63341
63342
63343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63345   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63346
63347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63348   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63349   {
63350     try {
63351       (arg1)->SetIndicatorHeightPolicy(arg2);
63352     } catch (std::out_of_range& e) {
63353       {
63354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63355       };
63356     } catch (std::exception& e) {
63357       {
63358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63359       };
63360     } catch (...) {
63361       {
63362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63363       };
63364     }
63365   }
63366 }
63367
63368
63369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63370   int jresult ;
63371   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63372   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63373
63374   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63375   {
63376     try {
63377       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63378     } catch (std::out_of_range& e) {
63379       {
63380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63381       };
63382     } catch (std::exception& e) {
63383       {
63384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63385       };
63386     } catch (...) {
63387       {
63388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63389       };
63390     }
63391   }
63392   jresult = (int)result;
63393   return jresult;
63394 }
63395
63396
63397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63398   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63399   float arg2 ;
63400
63401   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63402   arg2 = (float)jarg2;
63403   {
63404     try {
63405       (arg1)->SetIndicatorFixedHeight(arg2);
63406     } catch (std::out_of_range& e) {
63407       {
63408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63409       };
63410     } catch (std::exception& e) {
63411       {
63412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63413       };
63414     } catch (...) {
63415       {
63416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63417       };
63418     }
63419   }
63420 }
63421
63422
63423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63424   float jresult ;
63425   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63426   float result;
63427
63428   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63429   {
63430     try {
63431       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63432     } catch (std::out_of_range& e) {
63433       {
63434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63435       };
63436     } catch (std::exception& e) {
63437       {
63438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63439       };
63440     } catch (...) {
63441       {
63442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63443       };
63444     }
63445   }
63446   jresult = result;
63447   return jresult;
63448 }
63449
63450
63451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63452   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63453   float arg2 ;
63454
63455   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63456   arg2 = (float)jarg2;
63457   {
63458     try {
63459       (arg1)->SetIndicatorShowDuration(arg2);
63460     } catch (std::out_of_range& e) {
63461       {
63462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63463       };
63464     } catch (std::exception& e) {
63465       {
63466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63467       };
63468     } catch (...) {
63469       {
63470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63471       };
63472     }
63473   }
63474 }
63475
63476
63477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63478   float jresult ;
63479   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63480   float result;
63481
63482   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63483   {
63484     try {
63485       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63486     } catch (std::out_of_range& e) {
63487       {
63488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63489       };
63490     } catch (std::exception& e) {
63491       {
63492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63493       };
63494     } catch (...) {
63495       {
63496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63497       };
63498     }
63499   }
63500   jresult = result;
63501   return jresult;
63502 }
63503
63504
63505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63506   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63507   float arg2 ;
63508
63509   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63510   arg2 = (float)jarg2;
63511   {
63512     try {
63513       (arg1)->SetIndicatorHideDuration(arg2);
63514     } catch (std::out_of_range& e) {
63515       {
63516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63517       };
63518     } catch (std::exception& e) {
63519       {
63520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63521       };
63522     } catch (...) {
63523       {
63524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63525       };
63526     }
63527   }
63528 }
63529
63530
63531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63532   float jresult ;
63533   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63534   float result;
63535
63536   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63537   {
63538     try {
63539       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63540     } catch (std::out_of_range& e) {
63541       {
63542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63543       };
63544     } catch (std::exception& e) {
63545       {
63546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63547       };
63548     } catch (...) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63551       };
63552     }
63553   }
63554   jresult = result;
63555   return jresult;
63556 }
63557
63558
63559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63560   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63561
63562   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63563   {
63564     try {
63565       (arg1)->ShowIndicator();
63566     } catch (std::out_of_range& e) {
63567       {
63568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63569       };
63570     } catch (std::exception& e) {
63571       {
63572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63573       };
63574     } catch (...) {
63575       {
63576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63577       };
63578     }
63579   }
63580 }
63581
63582
63583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63584   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63585
63586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63587   {
63588     try {
63589       (arg1)->HideIndicator();
63590     } catch (std::out_of_range& e) {
63591       {
63592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63593       };
63594     } catch (std::exception& e) {
63595       {
63596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63597       };
63598     } catch (...) {
63599       {
63600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63601       };
63602     }
63603   }
63604 }
63605
63606
63607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63608   void * jresult ;
63609   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63610   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63611
63612   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63613   {
63614     try {
63615       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63616     } catch (std::out_of_range& e) {
63617       {
63618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63619       };
63620     } catch (std::exception& e) {
63621       {
63622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (...) {
63625       {
63626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63627       };
63628     }
63629   }
63630   jresult = (void *)result;
63631   return jresult;
63632 }
63633
63634
63635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63636   void * jresult ;
63637   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63638   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63639
63640   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63641   {
63642     try {
63643       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63644     } catch (std::out_of_range& e) {
63645       {
63646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63647       };
63648     } catch (std::exception& e) {
63649       {
63650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63651       };
63652     } catch (...) {
63653       {
63654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63655       };
63656     }
63657   }
63658   jresult = (void *)result;
63659   return jresult;
63660 }
63661
63662
63663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63664   int jresult ;
63665   int result;
63666
63667   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63668   jresult = (int)result;
63669   return jresult;
63670 }
63671
63672
63673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63674   int jresult ;
63675   int result;
63676
63677   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63678   jresult = (int)result;
63679   return jresult;
63680 }
63681
63682
63683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63684   int jresult ;
63685   int result;
63686
63687   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63688   jresult = (int)result;
63689   return jresult;
63690 }
63691
63692
63693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63694   int jresult ;
63695   int result;
63696
63697   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63698   jresult = (int)result;
63699   return jresult;
63700 }
63701
63702
63703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63704   int jresult ;
63705   int result;
63706
63707   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63708   jresult = (int)result;
63709   return jresult;
63710 }
63711
63712
63713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63714   int jresult ;
63715   int result;
63716
63717   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63718   jresult = (int)result;
63719   return jresult;
63720 }
63721
63722
63723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63724   int jresult ;
63725   int result;
63726
63727   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63728   jresult = (int)result;
63729   return jresult;
63730 }
63731
63732
63733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63734   int jresult ;
63735   int result;
63736
63737   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63738   jresult = (int)result;
63739   return jresult;
63740 }
63741
63742
63743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63744   int jresult ;
63745   int result;
63746
63747   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63748   jresult = (int)result;
63749   return jresult;
63750 }
63751
63752
63753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63754   int jresult ;
63755   int result;
63756
63757   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63758   jresult = (int)result;
63759   return jresult;
63760 }
63761
63762
63763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63764   int jresult ;
63765   int result;
63766
63767   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63768   jresult = (int)result;
63769   return jresult;
63770 }
63771
63772
63773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63774   int jresult ;
63775   int result;
63776
63777   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63778   jresult = (int)result;
63779   return jresult;
63780 }
63781
63782
63783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63784   int jresult ;
63785   int result;
63786
63787   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63788   jresult = (int)result;
63789   return jresult;
63790 }
63791
63792
63793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63794   int jresult ;
63795   int result;
63796
63797   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63798   jresult = (int)result;
63799   return jresult;
63800 }
63801
63802
63803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63804   void * jresult ;
63805   Dali::Toolkit::Scrollable::Property *result = 0 ;
63806
63807   {
63808     try {
63809       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63810     } catch (std::out_of_range& e) {
63811       {
63812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63813       };
63814     } catch (std::exception& e) {
63815       {
63816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63817       };
63818     } catch (...) {
63819       {
63820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63821       };
63822     }
63823   }
63824   jresult = (void *)result;
63825   return jresult;
63826 }
63827
63828
63829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63830   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63831
63832   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63833   {
63834     try {
63835       delete arg1;
63836     } catch (std::out_of_range& e) {
63837       {
63838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63839       };
63840     } catch (std::exception& e) {
63841       {
63842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63843       };
63844     } catch (...) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63847       };
63848     }
63849   }
63850 }
63851
63852
63853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63854   void * jresult ;
63855   Dali::Toolkit::Scrollable *result = 0 ;
63856
63857   {
63858     try {
63859       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63860     } catch (std::out_of_range& e) {
63861       {
63862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63863       };
63864     } catch (std::exception& e) {
63865       {
63866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63867       };
63868     } catch (...) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63871       };
63872     }
63873   }
63874   jresult = (void *)result;
63875   return jresult;
63876 }
63877
63878
63879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63880   void * jresult ;
63881   Dali::Toolkit::Scrollable *arg1 = 0 ;
63882   Dali::Toolkit::Scrollable *result = 0 ;
63883
63884   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63885   if (!arg1) {
63886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63887     return 0;
63888   }
63889   {
63890     try {
63891       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63892     } catch (std::out_of_range& e) {
63893       {
63894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63895       };
63896     } catch (std::exception& e) {
63897       {
63898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63899       };
63900     } catch (...) {
63901       {
63902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63903       };
63904     }
63905   }
63906   jresult = (void *)result;
63907   return jresult;
63908 }
63909
63910
63911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63912   void * jresult ;
63913   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63914   Dali::Toolkit::Scrollable *arg2 = 0 ;
63915   Dali::Toolkit::Scrollable *result = 0 ;
63916
63917   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63918   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63919   if (!arg2) {
63920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63921     return 0;
63922   }
63923   {
63924     try {
63925       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63926     } catch (std::out_of_range& e) {
63927       {
63928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63929       };
63930     } catch (std::exception& e) {
63931       {
63932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63933       };
63934     } catch (...) {
63935       {
63936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63937       };
63938     }
63939   }
63940   jresult = (void *)result;
63941   return jresult;
63942 }
63943
63944
63945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63946   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63947
63948   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63949   {
63950     try {
63951       delete arg1;
63952     } catch (std::out_of_range& e) {
63953       {
63954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63955       };
63956     } catch (std::exception& e) {
63957       {
63958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63959       };
63960     } catch (...) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63963       };
63964     }
63965   }
63966 }
63967
63968
63969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
63970   void * jresult ;
63971   Dali::BaseHandle arg1 ;
63972   Dali::BaseHandle *argp1 ;
63973   Dali::Toolkit::Scrollable result;
63974
63975   argp1 = (Dali::BaseHandle *)jarg1;
63976   if (!argp1) {
63977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63978     return 0;
63979   }
63980   arg1 = *argp1;
63981   {
63982     try {
63983       result = Dali::Toolkit::Scrollable::DownCast(arg1);
63984     } catch (std::out_of_range& e) {
63985       {
63986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63987       };
63988     } catch (std::exception& e) {
63989       {
63990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63991       };
63992     } catch (...) {
63993       {
63994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63995       };
63996     }
63997   }
63998   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
63999   return jresult;
64000 }
64001
64002
64003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64004   unsigned int jresult ;
64005   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64006   bool result;
64007
64008   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64009   {
64010     try {
64011       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64012     } catch (std::out_of_range& e) {
64013       {
64014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64015       };
64016     } catch (std::exception& e) {
64017       {
64018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64019       };
64020     } catch (...) {
64021       {
64022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64023       };
64024     }
64025   }
64026   jresult = result;
64027   return jresult;
64028 }
64029
64030
64031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64032   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64033   bool arg2 ;
64034
64035   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64036   arg2 = jarg2 ? true : false;
64037   {
64038     try {
64039       (arg1)->SetOvershootEnabled(arg2);
64040     } catch (std::out_of_range& e) {
64041       {
64042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64043       };
64044     } catch (std::exception& e) {
64045       {
64046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64047       };
64048     } catch (...) {
64049       {
64050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64051       };
64052     }
64053   }
64054 }
64055
64056
64057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64058   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64059   Dali::Vector4 *arg2 = 0 ;
64060
64061   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64062   arg2 = (Dali::Vector4 *)jarg2;
64063   if (!arg2) {
64064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64065     return ;
64066   }
64067   {
64068     try {
64069       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64070     } catch (std::out_of_range& e) {
64071       {
64072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64073       };
64074     } catch (std::exception& e) {
64075       {
64076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64077       };
64078     } catch (...) {
64079       {
64080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64081       };
64082     }
64083   }
64084 }
64085
64086
64087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64088   void * jresult ;
64089   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64090   Dali::Vector4 result;
64091
64092   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64093   {
64094     try {
64095       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64096     } catch (std::out_of_range& e) {
64097       {
64098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64099       };
64100     } catch (std::exception& e) {
64101       {
64102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (...) {
64105       {
64106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64107       };
64108     }
64109   }
64110   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64111   return jresult;
64112 }
64113
64114
64115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64116   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64117   float arg2 ;
64118
64119   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64120   arg2 = (float)jarg2;
64121   {
64122     try {
64123       (arg1)->SetOvershootAnimationSpeed(arg2);
64124     } catch (std::out_of_range& e) {
64125       {
64126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64127       };
64128     } catch (std::exception& e) {
64129       {
64130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64135       };
64136     }
64137   }
64138 }
64139
64140
64141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64142   float jresult ;
64143   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64144   float result;
64145
64146   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64147   {
64148     try {
64149       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64150     } catch (std::out_of_range& e) {
64151       {
64152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64153       };
64154     } catch (std::exception& e) {
64155       {
64156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64157       };
64158     } catch (...) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64161       };
64162     }
64163   }
64164   jresult = result;
64165   return jresult;
64166 }
64167
64168
64169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64170   void * jresult ;
64171   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64172   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64173
64174   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64175   {
64176     try {
64177       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64178     } catch (std::out_of_range& e) {
64179       {
64180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64181       };
64182     } catch (std::exception& e) {
64183       {
64184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64185       };
64186     } catch (...) {
64187       {
64188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64189       };
64190     }
64191   }
64192   jresult = (void *)result;
64193   return jresult;
64194 }
64195
64196
64197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64198   void * jresult ;
64199   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64200   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64201
64202   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64203   {
64204     try {
64205       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64206     } catch (std::out_of_range& e) {
64207       {
64208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64209       };
64210     } catch (std::exception& e) {
64211       {
64212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (...) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64217       };
64218     }
64219   }
64220   jresult = (void *)result;
64221   return jresult;
64222 }
64223
64224
64225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64226   void * jresult ;
64227   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64228   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64229
64230   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64231   {
64232     try {
64233       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64234     } catch (std::out_of_range& e) {
64235       {
64236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64237       };
64238     } catch (std::exception& e) {
64239       {
64240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64241       };
64242     } catch (...) {
64243       {
64244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64245       };
64246     }
64247   }
64248   jresult = (void *)result;
64249   return jresult;
64250 }
64251
64252
64253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64254   unsigned int jresult ;
64255   Dali::Toolkit::ControlOrientation::Type arg1 ;
64256   bool result;
64257
64258   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64259   {
64260     try {
64261       result = (bool)Dali::Toolkit::IsVertical(arg1);
64262     } catch (std::out_of_range& e) {
64263       {
64264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64265       };
64266     } catch (std::exception& e) {
64267       {
64268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64269       };
64270     } catch (...) {
64271       {
64272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64273       };
64274     }
64275   }
64276   jresult = result;
64277   return jresult;
64278 }
64279
64280
64281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64282   unsigned int jresult ;
64283   Dali::Toolkit::ControlOrientation::Type arg1 ;
64284   bool result;
64285
64286   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64287   {
64288     try {
64289       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64290     } catch (std::out_of_range& e) {
64291       {
64292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64293       };
64294     } catch (std::exception& e) {
64295       {
64296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64297       };
64298     } catch (...) {
64299       {
64300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64301       };
64302     }
64303   }
64304   jresult = result;
64305   return jresult;
64306 }
64307
64308
64309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64310   void * jresult ;
64311   unsigned int arg1 ;
64312   unsigned int arg2 ;
64313   Dali::Toolkit::ItemRange *result = 0 ;
64314
64315   arg1 = (unsigned int)jarg1;
64316   arg2 = (unsigned int)jarg2;
64317   {
64318     try {
64319       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
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 = (void *)result;
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64340   void * jresult ;
64341   Dali::Toolkit::ItemRange *arg1 = 0 ;
64342   Dali::Toolkit::ItemRange *result = 0 ;
64343
64344   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64345   if (!arg1) {
64346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64347     return 0;
64348   }
64349   {
64350     try {
64351       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64352     } catch (std::out_of_range& e) {
64353       {
64354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (std::exception& e) {
64357       {
64358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64359       };
64360     } catch (...) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64363       };
64364     }
64365   }
64366   jresult = (void *)result;
64367   return jresult;
64368 }
64369
64370
64371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64372   void * jresult ;
64373   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64374   Dali::Toolkit::ItemRange *arg2 = 0 ;
64375   Dali::Toolkit::ItemRange *result = 0 ;
64376
64377   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64378   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64379   if (!arg2) {
64380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64381     return 0;
64382   }
64383   {
64384     try {
64385       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64386     } catch (std::out_of_range& e) {
64387       {
64388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64389       };
64390     } catch (std::exception& e) {
64391       {
64392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64393       };
64394     } catch (...) {
64395       {
64396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64397       };
64398     }
64399   }
64400   jresult = (void *)result;
64401   return jresult;
64402 }
64403
64404
64405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64406   unsigned int jresult ;
64407   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64408   unsigned int arg2 ;
64409   bool result;
64410
64411   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64412   arg2 = (unsigned int)jarg2;
64413   {
64414     try {
64415       result = (bool)(arg1)->Within(arg2);
64416     } catch (std::out_of_range& e) {
64417       {
64418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64419       };
64420     } catch (std::exception& e) {
64421       {
64422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64423       };
64424     } catch (...) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64427       };
64428     }
64429   }
64430   jresult = result;
64431   return jresult;
64432 }
64433
64434
64435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64436   void * jresult ;
64437   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64438   Dali::Toolkit::ItemRange *arg2 = 0 ;
64439   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64440
64441   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64442   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64443   if (!arg2) {
64444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64445     return 0;
64446   }
64447   {
64448     try {
64449       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64450     } catch (std::out_of_range& e) {
64451       {
64452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64453       };
64454     } catch (std::exception& e) {
64455       {
64456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64457       };
64458     } catch (...) {
64459       {
64460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64461       };
64462     }
64463   }
64464   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64465   return jresult;
64466 }
64467
64468
64469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64470   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64471   unsigned int arg2 ;
64472
64473   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64474   arg2 = (unsigned int)jarg2;
64475   if (arg1) (arg1)->begin = arg2;
64476 }
64477
64478
64479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64480   unsigned int jresult ;
64481   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64482   unsigned int result;
64483
64484   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64485   result = (unsigned int) ((arg1)->begin);
64486   jresult = result;
64487   return jresult;
64488 }
64489
64490
64491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64492   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64493   unsigned int arg2 ;
64494
64495   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64496   arg2 = (unsigned int)jarg2;
64497   if (arg1) (arg1)->end = arg2;
64498 }
64499
64500
64501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64502   unsigned int jresult ;
64503   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64504   unsigned int result;
64505
64506   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64507   result = (unsigned int) ((arg1)->end);
64508   jresult = result;
64509   return jresult;
64510 }
64511
64512
64513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64514   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64515
64516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64517   {
64518     try {
64519       delete arg1;
64520     } catch (std::out_of_range& e) {
64521       {
64522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64523       };
64524     } catch (std::exception& e) {
64525       {
64526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64527       };
64528     } catch (...) {
64529       {
64530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64531       };
64532     }
64533   }
64534 }
64535
64536
64537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64538   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64539
64540   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64541   {
64542     try {
64543       delete arg1;
64544     } catch (std::out_of_range& e) {
64545       {
64546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64547       };
64548     } catch (std::exception& e) {
64549       {
64550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64551       };
64552     } catch (...) {
64553       {
64554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64555       };
64556     }
64557   }
64558 }
64559
64560
64561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64562   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64563   Dali::Toolkit::ControlOrientation::Type arg2 ;
64564
64565   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64566   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64567   {
64568     try {
64569       (arg1)->SetOrientation(arg2);
64570     } catch (std::out_of_range& e) {
64571       {
64572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64573       };
64574     } catch (std::exception& e) {
64575       {
64576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64577       };
64578     } catch (...) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64581       };
64582     }
64583   }
64584 }
64585
64586
64587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64588   int jresult ;
64589   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64590   Dali::Toolkit::ControlOrientation::Type result;
64591
64592   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64593   {
64594     try {
64595       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64596     } catch (std::out_of_range& e) {
64597       {
64598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64599       };
64600     } catch (std::exception& e) {
64601       {
64602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64603       };
64604     } catch (...) {
64605       {
64606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64607       };
64608     }
64609   }
64610   jresult = (int)result;
64611   return jresult;
64612 }
64613
64614
64615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64616   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64617   Dali::Property::Map *arg2 = 0 ;
64618
64619   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64620   arg2 = (Dali::Property::Map *)jarg2;
64621   if (!arg2) {
64622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64623     return ;
64624   }
64625   {
64626     try {
64627       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64628     } catch (std::out_of_range& e) {
64629       {
64630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64631       };
64632     } catch (std::exception& e) {
64633       {
64634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64635       };
64636     } catch (...) {
64637       {
64638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64639       };
64640     }
64641   }
64642 }
64643
64644
64645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64646   void * jresult ;
64647   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64648   Dali::Property::Map result;
64649
64650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64651   {
64652     try {
64653       result = (arg1)->GetLayoutProperties();
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (...) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64665       };
64666     }
64667   }
64668   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64669   return jresult;
64670 }
64671
64672
64673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64674   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64675   unsigned int arg2 ;
64676   Dali::Vector3 *arg3 = 0 ;
64677   Dali::Vector3 *arg4 = 0 ;
64678
64679   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64680   arg2 = (unsigned int)jarg2;
64681   arg3 = (Dali::Vector3 *)jarg3;
64682   if (!arg3) {
64683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64684     return ;
64685   }
64686   arg4 = (Dali::Vector3 *)jarg4;
64687   if (!arg4) {
64688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64689     return ;
64690   }
64691   {
64692     try {
64693       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64694     } catch (std::out_of_range& e) {
64695       {
64696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64697       };
64698     } catch (std::exception& e) {
64699       {
64700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64701       };
64702     } catch (...) {
64703       {
64704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64705       };
64706     }
64707   }
64708 }
64709
64710
64711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64712   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64713   Dali::Vector3 *arg2 = 0 ;
64714
64715   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64716   arg2 = (Dali::Vector3 *)jarg2;
64717   if (!arg2) {
64718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64719     return ;
64720   }
64721   {
64722     try {
64723       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64724     } catch (std::out_of_range& e) {
64725       {
64726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64727       };
64728     } catch (std::exception& e) {
64729       {
64730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64731       };
64732     } catch (...) {
64733       {
64734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64735       };
64736     }
64737   }
64738 }
64739
64740
64741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64742   float jresult ;
64743   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64744   unsigned int arg2 ;
64745   Dali::Vector3 arg3 ;
64746   Dali::Vector3 *argp3 ;
64747   float result;
64748
64749   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64750   arg2 = (unsigned int)jarg2;
64751   argp3 = (Dali::Vector3 *)jarg3;
64752   if (!argp3) {
64753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64754     return 0;
64755   }
64756   arg3 = *argp3;
64757   {
64758     try {
64759       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64760     } catch (std::out_of_range& e) {
64761       {
64762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64763       };
64764     } catch (std::exception& e) {
64765       {
64766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64767       };
64768     } catch (...) {
64769       {
64770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64771       };
64772     }
64773   }
64774   jresult = result;
64775   return jresult;
64776 }
64777
64778
64779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64780   float jresult ;
64781   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64782   float arg2 ;
64783   float result;
64784
64785   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64786   arg2 = (float)jarg2;
64787   {
64788     try {
64789       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64790     } catch (std::out_of_range& e) {
64791       {
64792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64793       };
64794     } catch (std::exception& e) {
64795       {
64796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64797       };
64798     } catch (...) {
64799       {
64800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64801       };
64802     }
64803   }
64804   jresult = result;
64805   return jresult;
64806 }
64807
64808
64809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64810   float jresult ;
64811   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64812   unsigned int arg2 ;
64813   float result;
64814
64815   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64816   arg2 = (unsigned int)jarg2;
64817   {
64818     try {
64819       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64820     } catch (std::out_of_range& e) {
64821       {
64822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64823       };
64824     } catch (std::exception& e) {
64825       {
64826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64827       };
64828     } catch (...) {
64829       {
64830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64831       };
64832     }
64833   }
64834   jresult = result;
64835   return jresult;
64836 }
64837
64838
64839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64840   void * jresult ;
64841   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64842   float arg2 ;
64843   Dali::Vector3 arg3 ;
64844   Dali::Vector3 *argp3 ;
64845   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64846
64847   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64848   arg2 = (float)jarg2;
64849   argp3 = (Dali::Vector3 *)jarg3;
64850   if (!argp3) {
64851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64852     return 0;
64853   }
64854   arg3 = *argp3;
64855   {
64856     try {
64857       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64858     } catch (std::out_of_range& e) {
64859       {
64860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64861       };
64862     } catch (std::exception& e) {
64863       {
64864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64865       };
64866     } catch (...) {
64867       {
64868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64869       };
64870     }
64871   }
64872   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64873   return jresult;
64874 }
64875
64876
64877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64878   float jresult ;
64879   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64880   int arg2 ;
64881   float arg3 ;
64882   Dali::Vector3 *arg4 = 0 ;
64883   float result;
64884
64885   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64886   arg2 = (int)jarg2;
64887   arg3 = (float)jarg3;
64888   arg4 = (Dali::Vector3 *)jarg4;
64889   if (!arg4) {
64890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64891     return 0;
64892   }
64893   {
64894     try {
64895       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64896     } catch (std::out_of_range& e) {
64897       {
64898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64899       };
64900     } catch (std::exception& e) {
64901       {
64902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64903       };
64904     } catch (...) {
64905       {
64906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64907       };
64908     }
64909   }
64910   jresult = result;
64911   return jresult;
64912 }
64913
64914
64915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64916   unsigned int jresult ;
64917   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64918   Dali::Vector3 arg2 ;
64919   Dali::Vector3 *argp2 ;
64920   unsigned int result;
64921
64922   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64923   argp2 = (Dali::Vector3 *)jarg2;
64924   if (!argp2) {
64925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64926     return 0;
64927   }
64928   arg2 = *argp2;
64929   {
64930     try {
64931       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64932     } catch (std::out_of_range& e) {
64933       {
64934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64935       };
64936     } catch (std::exception& e) {
64937       {
64938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64939       };
64940     } catch (...) {
64941       {
64942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64943       };
64944     }
64945   }
64946   jresult = result;
64947   return jresult;
64948 }
64949
64950
64951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64952   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64953   unsigned int arg2 ;
64954   Dali::Vector3 *arg3 = 0 ;
64955   Dali::Vector3 *arg4 = 0 ;
64956
64957   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64958   arg2 = (unsigned int)jarg2;
64959   arg3 = (Dali::Vector3 *)jarg3;
64960   if (!arg3) {
64961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64962     return ;
64963   }
64964   arg4 = (Dali::Vector3 *)jarg4;
64965   if (!arg4) {
64966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64967     return ;
64968   }
64969   {
64970     try {
64971       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64972     } catch (std::out_of_range& e) {
64973       {
64974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64975       };
64976     } catch (std::exception& e) {
64977       {
64978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64979       };
64980     } catch (...) {
64981       {
64982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64983       };
64984     }
64985   }
64986 }
64987
64988
64989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
64990   void * jresult ;
64991   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64992   Dali::Degree result;
64993
64994   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64995   {
64996     try {
64997       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
64998     } catch (std::out_of_range& e) {
64999       {
65000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65001       };
65002     } catch (std::exception& e) {
65003       {
65004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (...) {
65007       {
65008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65009       };
65010     }
65011   }
65012   jresult = new Dali::Degree((const Dali::Degree &)result);
65013   return jresult;
65014 }
65015
65016
65017 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65018   float jresult ;
65019   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65020   float result;
65021
65022   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65023   {
65024     try {
65025       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65026     } catch (std::out_of_range& e) {
65027       {
65028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65029       };
65030     } catch (std::exception& e) {
65031       {
65032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65033       };
65034     } catch (...) {
65035       {
65036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65037       };
65038     }
65039   }
65040   jresult = result;
65041   return jresult;
65042 }
65043
65044
65045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65046   float jresult ;
65047   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65048   float result;
65049
65050   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65051   {
65052     try {
65053       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65054     } catch (std::out_of_range& e) {
65055       {
65056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65057       };
65058     } catch (std::exception& e) {
65059       {
65060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65061       };
65062     } catch (...) {
65063       {
65064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65065       };
65066     }
65067   }
65068   jresult = result;
65069   return jresult;
65070 }
65071
65072
65073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65074   float jresult ;
65075   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65076   float result;
65077
65078   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65079   {
65080     try {
65081       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65082     } catch (std::out_of_range& e) {
65083       {
65084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (std::exception& e) {
65087       {
65088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65089       };
65090     } catch (...) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65093       };
65094     }
65095   }
65096   jresult = result;
65097   return jresult;
65098 }
65099
65100
65101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65102   int jresult ;
65103   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65104   int arg2 ;
65105   int arg3 ;
65106   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65107   bool arg5 ;
65108   int result;
65109
65110   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65111   arg2 = (int)jarg2;
65112   arg3 = (int)jarg3;
65113   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65114   arg5 = jarg5 ? true : false;
65115   {
65116     try {
65117       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65118     } catch (std::out_of_range& e) {
65119       {
65120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65121       };
65122     } catch (std::exception& e) {
65123       {
65124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65125       };
65126     } catch (...) {
65127       {
65128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65129       };
65130     }
65131   }
65132   jresult = result;
65133   return jresult;
65134 }
65135
65136
65137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65138   float jresult ;
65139   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65140   float result;
65141
65142   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65143   {
65144     try {
65145       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65146     } catch (std::out_of_range& e) {
65147       {
65148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65149       };
65150     } catch (std::exception& e) {
65151       {
65152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65153       };
65154     } catch (...) {
65155       {
65156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65157       };
65158     }
65159   }
65160   jresult = result;
65161   return jresult;
65162 }
65163
65164
65165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65166   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65167   Dali::Actor *arg2 = 0 ;
65168   int arg3 ;
65169   Dali::Vector3 *arg4 = 0 ;
65170   Dali::Actor *arg5 = 0 ;
65171
65172   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65173   arg2 = (Dali::Actor *)jarg2;
65174   if (!arg2) {
65175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65176     return ;
65177   }
65178   arg3 = (int)jarg3;
65179   arg4 = (Dali::Vector3 *)jarg4;
65180   if (!arg4) {
65181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65182     return ;
65183   }
65184   arg5 = (Dali::Actor *)jarg5;
65185   if (!arg5) {
65186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65187     return ;
65188   }
65189   {
65190     try {
65191       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65192     } catch (std::out_of_range& e) {
65193       {
65194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65195       };
65196     } catch (std::exception& e) {
65197       {
65198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65199       };
65200     } catch (...) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65203       };
65204     }
65205   }
65206 }
65207
65208
65209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65210   void * jresult ;
65211   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65212   int arg2 ;
65213   float arg3 ;
65214   Dali::Vector3 *arg4 = 0 ;
65215   Dali::Vector3 result;
65216
65217   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65218   arg2 = (int)jarg2;
65219   arg3 = (float)jarg3;
65220   arg4 = (Dali::Vector3 *)jarg4;
65221   if (!arg4) {
65222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65223     return 0;
65224   }
65225   {
65226     try {
65227       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65228     } catch (std::out_of_range& e) {
65229       {
65230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65231       };
65232     } catch (std::exception& e) {
65233       {
65234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65235       };
65236     } catch (...) {
65237       {
65238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65239       };
65240     }
65241   }
65242   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65243   return jresult;
65244 }
65245
65246
65247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65248   void * jresult ;
65249   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65250   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65251
65252   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65253   {
65254     try {
65255       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65256     } catch (std::out_of_range& e) {
65257       {
65258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (std::exception& e) {
65261       {
65262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65263       };
65264     } catch (...) {
65265       {
65266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65267       };
65268     }
65269   }
65270   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65271   return jresult;
65272 }
65273
65274
65275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65276   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65277
65278   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65279   {
65280     try {
65281       delete arg1;
65282     } catch (std::out_of_range& e) {
65283       {
65284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65285       };
65286     } catch (std::exception& e) {
65287       {
65288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65289       };
65290     } catch (...) {
65291       {
65292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65293       };
65294     }
65295   }
65296 }
65297
65298
65299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65300   unsigned int jresult ;
65301   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65302   unsigned int result;
65303
65304   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65305   {
65306     try {
65307       result = (unsigned int)(arg1)->GetNumberOfItems();
65308     } catch (std::out_of_range& e) {
65309       {
65310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65311       };
65312     } catch (std::exception& e) {
65313       {
65314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65315       };
65316     } catch (...) {
65317       {
65318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65319       };
65320     }
65321   }
65322   jresult = result;
65323   return jresult;
65324 }
65325
65326
65327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65328   void * jresult ;
65329   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65330   unsigned int arg2 ;
65331   Dali::Actor result;
65332
65333   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65334   arg2 = (unsigned int)jarg2;
65335   {
65336     try {
65337       result = (arg1)->NewItem(arg2);
65338     } catch (std::out_of_range& e) {
65339       {
65340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65341       };
65342     } catch (std::exception& e) {
65343       {
65344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65345       };
65346     } catch (...) {
65347       {
65348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65349       };
65350     }
65351   }
65352   jresult = new Dali::Actor((const Dali::Actor &)result);
65353   return jresult;
65354 }
65355
65356
65357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65358   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65359   unsigned int arg2 ;
65360   Dali::Actor arg3 ;
65361   Dali::Actor *argp3 ;
65362
65363   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65364   arg2 = (unsigned int)jarg2;
65365   argp3 = (Dali::Actor *)jarg3;
65366   if (!argp3) {
65367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65368     return ;
65369   }
65370   arg3 = *argp3;
65371   {
65372     try {
65373       (arg1)->ItemReleased(arg2,arg3);
65374     } catch (std::out_of_range& e) {
65375       {
65376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65377       };
65378     } catch (std::exception& e) {
65379       {
65380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65381       };
65382     } catch (...) {
65383       {
65384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65385       };
65386     }
65387   }
65388 }
65389
65390
65391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65392   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65393   unsigned int arg2 ;
65394   Dali::Actor arg3 ;
65395   Dali::Actor *argp3 ;
65396
65397   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65398   arg2 = (unsigned int)jarg2;
65399   argp3 = (Dali::Actor *)jarg3;
65400   if (!argp3) {
65401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65402     return ;
65403   }
65404   arg3 = *argp3;
65405   {
65406     try {
65407       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
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_new_ItemFactory() {
65426   void * jresult ;
65427   Dali::Toolkit::ItemFactory *result = 0 ;
65428
65429   {
65430     try {
65431       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65432     } catch (std::out_of_range& e) {
65433       {
65434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65435       };
65436     } catch (std::exception& e) {
65437       {
65438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65439       };
65440     } catch (...) {
65441       {
65442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65443       };
65444     }
65445   }
65446   jresult = (void *)result;
65447   return jresult;
65448 }
65449
65450
65451 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) {
65452   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65453   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65454   if (director) {
65455     director->swig_connect_director(callback0, callback1, callback2);
65456   }
65457 }
65458
65459
65460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65461   int jresult ;
65462   int result;
65463
65464   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65465   jresult = (int)result;
65466   return jresult;
65467 }
65468
65469
65470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65471   int jresult ;
65472   int result;
65473
65474   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65475   jresult = (int)result;
65476   return jresult;
65477 }
65478
65479
65480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65481   int jresult ;
65482   int result;
65483
65484   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65485   jresult = (int)result;
65486   return jresult;
65487 }
65488
65489
65490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65491   int jresult ;
65492   int result;
65493
65494   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65495   jresult = (int)result;
65496   return jresult;
65497 }
65498
65499
65500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65501   int jresult ;
65502   int result;
65503
65504   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65505   jresult = (int)result;
65506   return jresult;
65507 }
65508
65509
65510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65511   int jresult ;
65512   int result;
65513
65514   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65515   jresult = (int)result;
65516   return jresult;
65517 }
65518
65519
65520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65521   int jresult ;
65522   int result;
65523
65524   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65525   jresult = (int)result;
65526   return jresult;
65527 }
65528
65529
65530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65531   int jresult ;
65532   int result;
65533
65534   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65535   jresult = (int)result;
65536   return jresult;
65537 }
65538
65539
65540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65541   int jresult ;
65542   int result;
65543
65544   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65545   jresult = (int)result;
65546   return jresult;
65547 }
65548
65549
65550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65551   int jresult ;
65552   int result;
65553
65554   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65555   jresult = (int)result;
65556   return jresult;
65557 }
65558
65559
65560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65561   int jresult ;
65562   int result;
65563
65564   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65565   jresult = (int)result;
65566   return jresult;
65567 }
65568
65569
65570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65571   void * jresult ;
65572   Dali::Toolkit::ItemView::Property *result = 0 ;
65573
65574   {
65575     try {
65576       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65577     } catch (std::out_of_range& e) {
65578       {
65579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (std::exception& e) {
65582       {
65583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65588       };
65589     }
65590   }
65591   jresult = (void *)result;
65592   return jresult;
65593 }
65594
65595
65596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65597   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65598
65599   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65600   {
65601     try {
65602       delete arg1;
65603     } catch (std::out_of_range& e) {
65604       {
65605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65606       };
65607     } catch (std::exception& e) {
65608       {
65609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65610       };
65611     } catch (...) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65614       };
65615     }
65616   }
65617 }
65618
65619
65620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65621   void * jresult ;
65622   Dali::Toolkit::ItemView *result = 0 ;
65623
65624   {
65625     try {
65626       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65627     } catch (std::out_of_range& e) {
65628       {
65629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65630       };
65631     } catch (std::exception& e) {
65632       {
65633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65638       };
65639     }
65640   }
65641   jresult = (void *)result;
65642   return jresult;
65643 }
65644
65645
65646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65647   void * jresult ;
65648   Dali::Toolkit::ItemView *arg1 = 0 ;
65649   Dali::Toolkit::ItemView *result = 0 ;
65650
65651   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65652   if (!arg1) {
65653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65654     return 0;
65655   }
65656   {
65657     try {
65658       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673   jresult = (void *)result;
65674   return jresult;
65675 }
65676
65677
65678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65679   void * jresult ;
65680   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65681   Dali::Toolkit::ItemView *arg2 = 0 ;
65682   Dali::Toolkit::ItemView *result = 0 ;
65683
65684   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65685   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65686   if (!arg2) {
65687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65688     return 0;
65689   }
65690   {
65691     try {
65692       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65693     } catch (std::out_of_range& e) {
65694       {
65695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65696       };
65697     } catch (std::exception& e) {
65698       {
65699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65700       };
65701     } catch (...) {
65702       {
65703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65704       };
65705     }
65706   }
65707   jresult = (void *)result;
65708   return jresult;
65709 }
65710
65711
65712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65713   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65714
65715   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65716   {
65717     try {
65718       delete arg1;
65719     } catch (std::out_of_range& e) {
65720       {
65721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65722       };
65723     } catch (std::exception& e) {
65724       {
65725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65726       };
65727     } catch (...) {
65728       {
65729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65730       };
65731     }
65732   }
65733 }
65734
65735
65736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65737   void * jresult ;
65738   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65739   Dali::Toolkit::ItemView result;
65740
65741   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65742   if (!arg1) {
65743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65744     return 0;
65745   }
65746   {
65747     try {
65748       result = Dali::Toolkit::ItemView::New(*arg1);
65749     } catch (std::out_of_range& e) {
65750       {
65751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65752       };
65753     } catch (std::exception& e) {
65754       {
65755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65756       };
65757     } catch (...) {
65758       {
65759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65760       };
65761     }
65762   }
65763   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65764   return jresult;
65765 }
65766
65767
65768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65769   void * jresult ;
65770   Dali::BaseHandle arg1 ;
65771   Dali::BaseHandle *argp1 ;
65772   Dali::Toolkit::ItemView result;
65773
65774   argp1 = (Dali::BaseHandle *)jarg1;
65775   if (!argp1) {
65776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65777     return 0;
65778   }
65779   arg1 = *argp1;
65780   {
65781     try {
65782       result = Dali::Toolkit::ItemView::DownCast(arg1);
65783     } catch (std::out_of_range& e) {
65784       {
65785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65786       };
65787     } catch (std::exception& e) {
65788       {
65789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65790       };
65791     } catch (...) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65794       };
65795     }
65796   }
65797   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65803   unsigned int jresult ;
65804   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65805   unsigned int result;
65806
65807   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65808   {
65809     try {
65810       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65811     } catch (std::out_of_range& e) {
65812       {
65813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (std::exception& e) {
65816       {
65817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65818       };
65819     } catch (...) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65822       };
65823     }
65824   }
65825   jresult = result;
65826   return jresult;
65827 }
65828
65829
65830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65831   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65832   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65833
65834   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65835   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65836   if (!arg2) {
65837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65838     return ;
65839   }
65840   {
65841     try {
65842       (arg1)->AddLayout(*arg2);
65843     } catch (std::out_of_range& e) {
65844       {
65845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65846       };
65847     } catch (std::exception& e) {
65848       {
65849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65850       };
65851     } catch (...) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65854       };
65855     }
65856   }
65857 }
65858
65859
65860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65861   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65862   unsigned int arg2 ;
65863
65864   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65865   arg2 = (unsigned int)jarg2;
65866   {
65867     try {
65868       (arg1)->RemoveLayout(arg2);
65869     } catch (std::out_of_range& e) {
65870       {
65871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65872       };
65873     } catch (std::exception& e) {
65874       {
65875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65876       };
65877     } catch (...) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65880       };
65881     }
65882   }
65883 }
65884
65885
65886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65887   void * jresult ;
65888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65889   unsigned int arg2 ;
65890   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65891
65892   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65893   arg2 = (unsigned int)jarg2;
65894   {
65895     try {
65896       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65897     } catch (std::out_of_range& e) {
65898       {
65899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65900       };
65901     } catch (std::exception& e) {
65902       {
65903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65904       };
65905     } catch (...) {
65906       {
65907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65908       };
65909     }
65910   }
65911   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65912   return jresult;
65913 }
65914
65915
65916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65917   void * jresult ;
65918   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65919   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65920
65921   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65922   {
65923     try {
65924       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65925     } catch (std::out_of_range& e) {
65926       {
65927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65928       };
65929     } catch (std::exception& e) {
65930       {
65931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65932       };
65933     } catch (...) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65936       };
65937     }
65938   }
65939   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65940   return jresult;
65941 }
65942
65943
65944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65945   float jresult ;
65946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65947   Dali::Toolkit::ItemId arg2 ;
65948   float result;
65949
65950   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65951   arg2 = (Dali::Toolkit::ItemId)jarg2;
65952   {
65953     try {
65954       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65955     } catch (std::out_of_range& e) {
65956       {
65957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65958       };
65959     } catch (std::exception& e) {
65960       {
65961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65962       };
65963     } catch (...) {
65964       {
65965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65966       };
65967     }
65968   }
65969   jresult = result;
65970   return jresult;
65971 }
65972
65973
65974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
65975   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65976   unsigned int arg2 ;
65977   Dali::Vector3 arg3 ;
65978   float arg4 ;
65979   Dali::Vector3 *argp3 ;
65980
65981   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65982   arg2 = (unsigned int)jarg2;
65983   argp3 = (Dali::Vector3 *)jarg3;
65984   if (!argp3) {
65985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65986     return ;
65987   }
65988   arg3 = *argp3;
65989   arg4 = (float)jarg4;
65990   {
65991     try {
65992       (arg1)->ActivateLayout(arg2,arg3,arg4);
65993     } catch (std::out_of_range& e) {
65994       {
65995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65996       };
65997     } catch (std::exception& e) {
65998       {
65999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66000       };
66001     } catch (...) {
66002       {
66003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66004       };
66005     }
66006   }
66007 }
66008
66009
66010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66012
66013   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66014   {
66015     try {
66016       (arg1)->DeactivateCurrentLayout();
66017     } catch (std::out_of_range& e) {
66018       {
66019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66020       };
66021     } catch (std::exception& e) {
66022       {
66023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66024       };
66025     } catch (...) {
66026       {
66027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66028       };
66029     }
66030   }
66031 }
66032
66033
66034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66035   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66036   float arg2 ;
66037
66038   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66039   arg2 = (float)jarg2;
66040   {
66041     try {
66042       (arg1)->SetMinimumSwipeSpeed(arg2);
66043     } catch (std::out_of_range& e) {
66044       {
66045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66046       };
66047     } catch (std::exception& e) {
66048       {
66049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66050       };
66051     } catch (...) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66054       };
66055     }
66056   }
66057 }
66058
66059
66060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66061   float jresult ;
66062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66063   float result;
66064
66065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66066   {
66067     try {
66068       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66069     } catch (std::out_of_range& e) {
66070       {
66071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66072       };
66073     } catch (std::exception& e) {
66074       {
66075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (...) {
66078       {
66079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66080       };
66081     }
66082   }
66083   jresult = result;
66084   return jresult;
66085 }
66086
66087
66088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66089   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66090   float arg2 ;
66091
66092   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66093   arg2 = (float)jarg2;
66094   {
66095     try {
66096       (arg1)->SetMinimumSwipeDistance(arg2);
66097     } catch (std::out_of_range& e) {
66098       {
66099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66100       };
66101     } catch (std::exception& e) {
66102       {
66103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66104       };
66105     } catch (...) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66108       };
66109     }
66110   }
66111 }
66112
66113
66114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66115   float jresult ;
66116   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66117   float result;
66118
66119   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66120   {
66121     try {
66122       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66130       };
66131     } catch (...) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66134       };
66135     }
66136   }
66137   jresult = result;
66138   return jresult;
66139 }
66140
66141
66142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66143   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66144   float arg2 ;
66145
66146   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66147   arg2 = (float)jarg2;
66148   {
66149     try {
66150       (arg1)->SetWheelScrollDistanceStep(arg2);
66151     } catch (std::out_of_range& e) {
66152       {
66153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66154       };
66155     } catch (std::exception& e) {
66156       {
66157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66158       };
66159     } catch (...) {
66160       {
66161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66162       };
66163     }
66164   }
66165 }
66166
66167
66168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66169   float jresult ;
66170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66171   float result;
66172
66173   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66174   {
66175     try {
66176       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66177     } catch (std::out_of_range& e) {
66178       {
66179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66180       };
66181     } catch (std::exception& e) {
66182       {
66183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66184       };
66185     } catch (...) {
66186       {
66187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66188       };
66189     }
66190   }
66191   jresult = result;
66192   return jresult;
66193 }
66194
66195
66196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66197   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66198   bool arg2 ;
66199
66200   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66201   arg2 = jarg2 ? true : false;
66202   {
66203     try {
66204       (arg1)->SetAnchoring(arg2);
66205     } catch (std::out_of_range& e) {
66206       {
66207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (std::exception& e) {
66210       {
66211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66216       };
66217     }
66218   }
66219 }
66220
66221
66222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66223   unsigned int jresult ;
66224   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66225   bool result;
66226
66227   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66228   {
66229     try {
66230       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66231     } catch (std::out_of_range& e) {
66232       {
66233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66234       };
66235     } catch (std::exception& e) {
66236       {
66237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66238       };
66239     } catch (...) {
66240       {
66241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66242       };
66243     }
66244   }
66245   jresult = result;
66246   return jresult;
66247 }
66248
66249
66250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66251   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66252   float arg2 ;
66253
66254   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66255   arg2 = (float)jarg2;
66256   {
66257     try {
66258       (arg1)->SetAnchoringDuration(arg2);
66259     } catch (std::out_of_range& e) {
66260       {
66261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66262       };
66263     } catch (std::exception& e) {
66264       {
66265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66266       };
66267     } catch (...) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66270       };
66271     }
66272   }
66273 }
66274
66275
66276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66277   float jresult ;
66278   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66279   float result;
66280
66281   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66282   {
66283     try {
66284       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66285     } catch (std::out_of_range& e) {
66286       {
66287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66288       };
66289     } catch (std::exception& e) {
66290       {
66291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66292       };
66293     } catch (...) {
66294       {
66295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66296       };
66297     }
66298   }
66299   jresult = result;
66300   return jresult;
66301 }
66302
66303
66304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66305   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66306   Dali::Toolkit::ItemId arg2 ;
66307   float arg3 ;
66308
66309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66310   arg2 = (Dali::Toolkit::ItemId)jarg2;
66311   arg3 = (float)jarg3;
66312   {
66313     try {
66314       (arg1)->ScrollToItem(arg2,arg3);
66315     } catch (std::out_of_range& e) {
66316       {
66317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66318       };
66319     } catch (std::exception& e) {
66320       {
66321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66322       };
66323     } catch (...) {
66324       {
66325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66326       };
66327     }
66328   }
66329 }
66330
66331
66332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66334   float arg2 ;
66335
66336   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66337   arg2 = (float)jarg2;
66338   {
66339     try {
66340       (arg1)->SetRefreshInterval(arg2);
66341     } catch (std::out_of_range& e) {
66342       {
66343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66344       };
66345     } catch (std::exception& e) {
66346       {
66347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66348       };
66349     } catch (...) {
66350       {
66351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66352       };
66353     }
66354   }
66355 }
66356
66357
66358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66359   float jresult ;
66360   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66361   float result;
66362
66363   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66364   {
66365     try {
66366       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66367     } catch (std::out_of_range& e) {
66368       {
66369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66370       };
66371     } catch (std::exception& e) {
66372       {
66373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66374       };
66375     } catch (...) {
66376       {
66377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66378       };
66379     }
66380   }
66381   jresult = result;
66382   return jresult;
66383 }
66384
66385
66386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66387   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66388
66389   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66390   {
66391     try {
66392       (arg1)->Refresh();
66393     } catch (std::out_of_range& e) {
66394       {
66395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (std::exception& e) {
66398       {
66399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66404       };
66405     }
66406   }
66407 }
66408
66409
66410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66411   void * jresult ;
66412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66413   Dali::Toolkit::ItemId arg2 ;
66414   Dali::Actor result;
66415
66416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66417   arg2 = (Dali::Toolkit::ItemId)jarg2;
66418   {
66419     try {
66420       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66421     } catch (std::out_of_range& e) {
66422       {
66423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66424       };
66425     } catch (std::exception& e) {
66426       {
66427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66428       };
66429     } catch (...) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66432       };
66433     }
66434   }
66435   jresult = new Dali::Actor((const Dali::Actor &)result);
66436   return jresult;
66437 }
66438
66439
66440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66441   unsigned int jresult ;
66442   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66443   Dali::Actor arg2 ;
66444   Dali::Actor *argp2 ;
66445   Dali::Toolkit::ItemId result;
66446
66447   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66448   argp2 = (Dali::Actor *)jarg2;
66449   if (!argp2) {
66450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66451     return 0;
66452   }
66453   arg2 = *argp2;
66454   {
66455     try {
66456       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66457     } catch (std::out_of_range& e) {
66458       {
66459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66460       };
66461     } catch (std::exception& e) {
66462       {
66463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66464       };
66465     } catch (...) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66468       };
66469     }
66470   }
66471   jresult = result;
66472   return jresult;
66473 }
66474
66475
66476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66478   Dali::Toolkit::Item arg2 ;
66479   float arg3 ;
66480   Dali::Toolkit::Item *argp2 ;
66481
66482   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66483   argp2 = (Dali::Toolkit::Item *)jarg2;
66484   if (!argp2) {
66485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66486     return ;
66487   }
66488   arg2 = *argp2;
66489   arg3 = (float)jarg3;
66490   {
66491     try {
66492       (arg1)->InsertItem(arg2,arg3);
66493     } catch (std::out_of_range& e) {
66494       {
66495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66496       };
66497     } catch (std::exception& e) {
66498       {
66499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66500       };
66501     } catch (...) {
66502       {
66503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66504       };
66505     }
66506   }
66507 }
66508
66509
66510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66512   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66513   float arg3 ;
66514
66515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66516   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66517   if (!arg2) {
66518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66519     return ;
66520   }
66521   arg3 = (float)jarg3;
66522   {
66523     try {
66524       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66525     } catch (std::out_of_range& e) {
66526       {
66527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66528       };
66529     } catch (std::exception& e) {
66530       {
66531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66532       };
66533     } catch (...) {
66534       {
66535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66536       };
66537     }
66538   }
66539 }
66540
66541
66542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66544   Dali::Toolkit::ItemId arg2 ;
66545   float arg3 ;
66546
66547   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66548   arg2 = (Dali::Toolkit::ItemId)jarg2;
66549   arg3 = (float)jarg3;
66550   {
66551     try {
66552       (arg1)->RemoveItem(arg2,arg3);
66553     } catch (std::out_of_range& e) {
66554       {
66555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66556       };
66557     } catch (std::exception& e) {
66558       {
66559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66560       };
66561     } catch (...) {
66562       {
66563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66564       };
66565     }
66566   }
66567 }
66568
66569
66570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66571   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66572   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66573   float arg3 ;
66574
66575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66576   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66577   if (!arg2) {
66578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66579     return ;
66580   }
66581   arg3 = (float)jarg3;
66582   {
66583     try {
66584       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66585     } catch (std::out_of_range& e) {
66586       {
66587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66588       };
66589     } catch (std::exception& e) {
66590       {
66591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66592       };
66593     } catch (...) {
66594       {
66595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66596       };
66597     }
66598   }
66599 }
66600
66601
66602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66604   Dali::Toolkit::Item arg2 ;
66605   float arg3 ;
66606   Dali::Toolkit::Item *argp2 ;
66607
66608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66609   argp2 = (Dali::Toolkit::Item *)jarg2;
66610   if (!argp2) {
66611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66612     return ;
66613   }
66614   arg2 = *argp2;
66615   arg3 = (float)jarg3;
66616   {
66617     try {
66618       (arg1)->ReplaceItem(arg2,arg3);
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66626       };
66627     } catch (...) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66630       };
66631     }
66632   }
66633 }
66634
66635
66636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66638   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66639   float arg3 ;
66640
66641   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66642   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66643   if (!arg2) {
66644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66645     return ;
66646   }
66647   arg3 = (float)jarg3;
66648   {
66649     try {
66650       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66651     } catch (std::out_of_range& e) {
66652       {
66653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66654       };
66655     } catch (std::exception& e) {
66656       {
66657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66658       };
66659     } catch (...) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66662       };
66663     }
66664   }
66665 }
66666
66667
66668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66670   Dali::Vector3 *arg2 = 0 ;
66671
66672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66673   arg2 = (Dali::Vector3 *)jarg2;
66674   if (!arg2) {
66675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66676     return ;
66677   }
66678   {
66679     try {
66680       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66681     } catch (std::out_of_range& e) {
66682       {
66683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66684       };
66685     } catch (std::exception& e) {
66686       {
66687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66688       };
66689     } catch (...) {
66690       {
66691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66692       };
66693     }
66694   }
66695 }
66696
66697
66698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66699   void * jresult ;
66700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66701   Dali::Vector3 result;
66702
66703   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66704   {
66705     try {
66706       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66707     } catch (std::out_of_range& e) {
66708       {
66709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66710       };
66711     } catch (std::exception& e) {
66712       {
66713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (...) {
66716       {
66717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66718       };
66719     }
66720   }
66721   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66722   return jresult;
66723 }
66724
66725
66726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66727   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66728   Dali::Vector3 *arg2 = 0 ;
66729
66730   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66731   arg2 = (Dali::Vector3 *)jarg2;
66732   if (!arg2) {
66733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66734     return ;
66735   }
66736   {
66737     try {
66738       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66739     } catch (std::out_of_range& e) {
66740       {
66741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66742       };
66743     } catch (std::exception& e) {
66744       {
66745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66746       };
66747     } catch (...) {
66748       {
66749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66750       };
66751     }
66752   }
66753 }
66754
66755
66756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66757   void * jresult ;
66758   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66759   Dali::Vector3 result;
66760
66761   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66762   {
66763     try {
66764       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66765     } catch (std::out_of_range& e) {
66766       {
66767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66768       };
66769     } catch (std::exception& e) {
66770       {
66771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66772       };
66773     } catch (...) {
66774       {
66775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66776       };
66777     }
66778   }
66779   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66780   return jresult;
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66785   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66786   Dali::Toolkit::ItemRange *arg2 = 0 ;
66787
66788   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66789   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66790   if (!arg2) {
66791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66792     return ;
66793   }
66794   {
66795     try {
66796       (arg1)->GetItemsRange(*arg2);
66797     } catch (std::out_of_range& e) {
66798       {
66799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66800       };
66801     } catch (std::exception& e) {
66802       {
66803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (...) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66808       };
66809     }
66810   }
66811 }
66812
66813
66814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66815   void * jresult ;
66816   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66817   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66818
66819   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66820   {
66821     try {
66822       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66823     } catch (std::out_of_range& e) {
66824       {
66825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66826       };
66827     } catch (std::exception& e) {
66828       {
66829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66834       };
66835     }
66836   }
66837   jresult = (void *)result;
66838   return jresult;
66839 }
66840
66841
66842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66843   Dali::Vector3 *arg1 = 0 ;
66844   PropertyInputContainer *arg2 = 0 ;
66845
66846   arg1 = (Dali::Vector3 *)jarg1;
66847   if (!arg1) {
66848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66849     return ;
66850   }
66851   arg2 = (PropertyInputContainer *)jarg2;
66852   if (!arg2) {
66853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66854     return ;
66855   }
66856   {
66857     try {
66858       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66859     } catch (std::out_of_range& e) {
66860       {
66861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66862       };
66863     } catch (std::exception& e) {
66864       {
66865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66866       };
66867     } catch (...) {
66868       {
66869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66870       };
66871     }
66872   }
66873 }
66874
66875
66876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66877   Dali::Vector3 *arg1 = 0 ;
66878   PropertyInputContainer *arg2 = 0 ;
66879
66880   arg1 = (Dali::Vector3 *)jarg1;
66881   if (!arg1) {
66882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66883     return ;
66884   }
66885   arg2 = (PropertyInputContainer *)jarg2;
66886   if (!arg2) {
66887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66888     return ;
66889   }
66890   {
66891     try {
66892       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66893     } catch (std::out_of_range& e) {
66894       {
66895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66896       };
66897     } catch (std::exception& e) {
66898       {
66899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66904       };
66905     }
66906   }
66907 }
66908
66909
66910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66911   void * jresult ;
66912   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66913
66914   {
66915     try {
66916       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66924       };
66925     } catch (...) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66928       };
66929     }
66930   }
66931   jresult = (void *)result;
66932   return jresult;
66933 }
66934
66935
66936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66937   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66938
66939   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66940   {
66941     try {
66942       delete arg1;
66943     } catch (std::out_of_range& e) {
66944       {
66945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66946       };
66947     } catch (std::exception& e) {
66948       {
66949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66950       };
66951     } catch (...) {
66952       {
66953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66954       };
66955     }
66956   }
66957 }
66958
66959
66960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
66961   void * jresult ;
66962   Dali::Path arg1 ;
66963   Dali::Vector3 *arg2 = 0 ;
66964   Dali::Property::Index arg3 ;
66965   Dali::Vector3 *arg4 = 0 ;
66966   unsigned int arg5 ;
66967   Dali::Path *argp1 ;
66968   Dali::Toolkit::ScrollViewPagePathEffect result;
66969
66970   argp1 = (Dali::Path *)jarg1;
66971   if (!argp1) {
66972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
66973     return 0;
66974   }
66975   arg1 = *argp1;
66976   arg2 = (Dali::Vector3 *)jarg2;
66977   if (!arg2) {
66978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66979     return 0;
66980   }
66981   arg3 = (Dali::Property::Index)jarg3;
66982   arg4 = (Dali::Vector3 *)jarg4;
66983   if (!arg4) {
66984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66985     return 0;
66986   }
66987   arg5 = (unsigned int)jarg5;
66988   {
66989     try {
66990       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
66991     } catch (std::out_of_range& e) {
66992       {
66993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66994       };
66995     } catch (std::exception& e) {
66996       {
66997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66998       };
66999     } catch (...) {
67000       {
67001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67002       };
67003     }
67004   }
67005   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67006   return jresult;
67007 }
67008
67009
67010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67011   void * jresult ;
67012   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67013
67014   {
67015     try {
67016       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67017     } catch (std::out_of_range& e) {
67018       {
67019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67020       };
67021     } catch (std::exception& e) {
67022       {
67023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67024       };
67025     } catch (...) {
67026       {
67027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67028       };
67029     }
67030   }
67031   jresult = (void *)result;
67032   return jresult;
67033 }
67034
67035
67036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67037   void * jresult ;
67038   Dali::BaseHandle arg1 ;
67039   Dali::BaseHandle *argp1 ;
67040   Dali::Toolkit::ScrollViewPagePathEffect result;
67041
67042   argp1 = (Dali::BaseHandle *)jarg1;
67043   if (!argp1) {
67044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67045     return 0;
67046   }
67047   arg1 = *argp1;
67048   {
67049     try {
67050       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67051     } catch (std::out_of_range& e) {
67052       {
67053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67054       };
67055     } catch (std::exception& e) {
67056       {
67057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67058       };
67059     } catch (...) {
67060       {
67061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67062       };
67063     }
67064   }
67065   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67066   return jresult;
67067 }
67068
67069
67070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67071   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67072   Dali::Actor arg2 ;
67073   unsigned int arg3 ;
67074   Dali::Actor *argp2 ;
67075
67076   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67077   argp2 = (Dali::Actor *)jarg2;
67078   if (!argp2) {
67079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67080     return ;
67081   }
67082   arg2 = *argp2;
67083   arg3 = (unsigned int)jarg3;
67084   {
67085     try {
67086       (arg1)->ApplyToPage(arg2,arg3);
67087     } catch (std::out_of_range& e) {
67088       {
67089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67090       };
67091     } catch (std::exception& e) {
67092       {
67093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (...) {
67096       {
67097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67098       };
67099     }
67100   }
67101 }
67102
67103
67104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67105   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67106
67107   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67108   {
67109     try {
67110       delete arg1;
67111     } catch (std::out_of_range& e) {
67112       {
67113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67114       };
67115     } catch (std::exception& e) {
67116       {
67117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67118       };
67119     } catch (...) {
67120       {
67121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67122       };
67123     }
67124   }
67125 }
67126
67127
67128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67129   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67130   Dali::Toolkit::ClampState arg2 ;
67131
67132   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67133   arg2 = (Dali::Toolkit::ClampState)jarg2;
67134   if (arg1) (arg1)->x = arg2;
67135 }
67136
67137
67138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67139   int jresult ;
67140   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67141   Dali::Toolkit::ClampState result;
67142
67143   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67144   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67145   jresult = (int)result;
67146   return jresult;
67147 }
67148
67149
67150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67151   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67152   Dali::Toolkit::ClampState arg2 ;
67153
67154   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67155   arg2 = (Dali::Toolkit::ClampState)jarg2;
67156   if (arg1) (arg1)->y = arg2;
67157 }
67158
67159
67160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67161   int jresult ;
67162   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67163   Dali::Toolkit::ClampState result;
67164
67165   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67166   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67167   jresult = (int)result;
67168   return jresult;
67169 }
67170
67171
67172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67173   void * jresult ;
67174   Dali::Toolkit::ClampState2D *result = 0 ;
67175
67176   {
67177     try {
67178       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67179     } catch (std::out_of_range& e) {
67180       {
67181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (std::exception& e) {
67184       {
67185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (...) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67190       };
67191     }
67192   }
67193   jresult = (void *)result;
67194   return jresult;
67195 }
67196
67197
67198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67199   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67200
67201   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67202   {
67203     try {
67204       delete arg1;
67205     } catch (std::out_of_range& e) {
67206       {
67207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67208       };
67209     } catch (std::exception& e) {
67210       {
67211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67212       };
67213     } catch (...) {
67214       {
67215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67216       };
67217     }
67218   }
67219 }
67220
67221
67222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67223   void * jresult ;
67224   float arg1 ;
67225   float arg2 ;
67226   bool arg3 ;
67227   Dali::Toolkit::RulerDomain *result = 0 ;
67228
67229   arg1 = (float)jarg1;
67230   arg2 = (float)jarg2;
67231   arg3 = jarg3 ? true : false;
67232   {
67233     try {
67234       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67235     } catch (std::out_of_range& e) {
67236       {
67237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67238       };
67239     } catch (std::exception& e) {
67240       {
67241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67242       };
67243     } catch (...) {
67244       {
67245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67246       };
67247     }
67248   }
67249   jresult = (void *)result;
67250   return jresult;
67251 }
67252
67253
67254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67255   void * jresult ;
67256   float arg1 ;
67257   float arg2 ;
67258   Dali::Toolkit::RulerDomain *result = 0 ;
67259
67260   arg1 = (float)jarg1;
67261   arg2 = (float)jarg2;
67262   {
67263     try {
67264       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67265     } catch (std::out_of_range& e) {
67266       {
67267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67268       };
67269     } catch (std::exception& e) {
67270       {
67271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67272       };
67273     } catch (...) {
67274       {
67275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67276       };
67277     }
67278   }
67279   jresult = (void *)result;
67280   return jresult;
67281 }
67282
67283
67284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67285   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67286   float arg2 ;
67287
67288   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67289   arg2 = (float)jarg2;
67290   if (arg1) (arg1)->min = arg2;
67291 }
67292
67293
67294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67295   float jresult ;
67296   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67297   float result;
67298
67299   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67300   result = (float) ((arg1)->min);
67301   jresult = result;
67302   return jresult;
67303 }
67304
67305
67306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67307   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67308   float arg2 ;
67309
67310   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67311   arg2 = (float)jarg2;
67312   if (arg1) (arg1)->max = arg2;
67313 }
67314
67315
67316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67317   float jresult ;
67318   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67319   float result;
67320
67321   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67322   result = (float) ((arg1)->max);
67323   jresult = result;
67324   return jresult;
67325 }
67326
67327
67328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67329   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67330   bool arg2 ;
67331
67332   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67333   arg2 = jarg2 ? true : false;
67334   if (arg1) (arg1)->enabled = arg2;
67335 }
67336
67337
67338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67339   unsigned int jresult ;
67340   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67341   bool result;
67342
67343   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67344   result = (bool) ((arg1)->enabled);
67345   jresult = result;
67346   return jresult;
67347 }
67348
67349
67350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67351   float jresult ;
67352   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67353   float arg2 ;
67354   float arg3 ;
67355   float arg4 ;
67356   float result;
67357
67358   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67359   arg2 = (float)jarg2;
67360   arg3 = (float)jarg3;
67361   arg4 = (float)jarg4;
67362   {
67363     try {
67364       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67365     } catch (std::out_of_range& e) {
67366       {
67367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67368       };
67369     } catch (std::exception& e) {
67370       {
67371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67372       };
67373     } catch (...) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67376       };
67377     }
67378   }
67379   jresult = result;
67380   return jresult;
67381 }
67382
67383
67384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67385   float jresult ;
67386   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67387   float arg2 ;
67388   float arg3 ;
67389   float result;
67390
67391   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67392   arg2 = (float)jarg2;
67393   arg3 = (float)jarg3;
67394   {
67395     try {
67396       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67397     } catch (std::out_of_range& e) {
67398       {
67399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67400       };
67401     } catch (std::exception& e) {
67402       {
67403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67404       };
67405     } catch (...) {
67406       {
67407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67408       };
67409     }
67410   }
67411   jresult = result;
67412   return jresult;
67413 }
67414
67415
67416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67417   float jresult ;
67418   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67419   float arg2 ;
67420   float result;
67421
67422   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67423   arg2 = (float)jarg2;
67424   {
67425     try {
67426       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67427     } catch (std::out_of_range& e) {
67428       {
67429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67430       };
67431     } catch (std::exception& e) {
67432       {
67433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67434       };
67435     } catch (...) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67438       };
67439     }
67440   }
67441   jresult = result;
67442   return jresult;
67443 }
67444
67445
67446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67447   float jresult ;
67448   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67449   float arg2 ;
67450   float arg3 ;
67451   float arg4 ;
67452   Dali::Toolkit::ClampState *arg5 = 0 ;
67453   float result;
67454
67455   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67456   arg2 = (float)jarg2;
67457   arg3 = (float)jarg3;
67458   arg4 = (float)jarg4;
67459   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67460   if (!arg5) {
67461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67462     return 0;
67463   }
67464   {
67465     try {
67466       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67467     } catch (std::out_of_range& e) {
67468       {
67469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (std::exception& e) {
67472       {
67473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (...) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67478       };
67479     }
67480   }
67481   jresult = result;
67482   return jresult;
67483 }
67484
67485
67486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67487   float jresult ;
67488   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67489   float result;
67490
67491   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67492   {
67493     try {
67494       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67495     } catch (std::out_of_range& e) {
67496       {
67497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (std::exception& e) {
67500       {
67501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (...) {
67504       {
67505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67506       };
67507     }
67508   }
67509   jresult = result;
67510   return jresult;
67511 }
67512
67513
67514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67515   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67516
67517   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67518   {
67519     try {
67520       delete arg1;
67521     } catch (std::out_of_range& e) {
67522       {
67523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67524       };
67525     } catch (std::exception& e) {
67526       {
67527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67528       };
67529     } catch (...) {
67530       {
67531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67532       };
67533     }
67534   }
67535 }
67536
67537
67538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67539   float jresult ;
67540   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67541   float arg2 ;
67542   float arg3 ;
67543   float result;
67544
67545   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67546   arg2 = (float)jarg2;
67547   arg3 = (float)jarg3;
67548   {
67549     try {
67550       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67551     } catch (std::out_of_range& e) {
67552       {
67553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67554       };
67555     } catch (std::exception& e) {
67556       {
67557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67558       };
67559     } catch (...) {
67560       {
67561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67562       };
67563     }
67564   }
67565   jresult = result;
67566   return jresult;
67567 }
67568
67569
67570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67571   float jresult ;
67572   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67573   float arg2 ;
67574   float result;
67575
67576   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67577   arg2 = (float)jarg2;
67578   {
67579     try {
67580       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67581     } catch (std::out_of_range& e) {
67582       {
67583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67584       };
67585     } catch (std::exception& e) {
67586       {
67587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67588       };
67589     } catch (...) {
67590       {
67591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67592       };
67593     }
67594   }
67595   jresult = result;
67596   return jresult;
67597 }
67598
67599
67600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67601   float jresult ;
67602   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67603   unsigned int arg2 ;
67604   unsigned int *arg3 = 0 ;
67605   bool arg4 ;
67606   float result;
67607
67608   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67609   arg2 = (unsigned int)jarg2;
67610   arg3 = (unsigned int *)jarg3;
67611   arg4 = jarg4 ? true : false;
67612   {
67613     try {
67614       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67615     } catch (std::out_of_range& e) {
67616       {
67617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67618       };
67619     } catch (std::exception& e) {
67620       {
67621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67622       };
67623     } catch (...) {
67624       {
67625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67626       };
67627     }
67628   }
67629   jresult = result;
67630   return jresult;
67631 }
67632
67633
67634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67635   unsigned int jresult ;
67636   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67637   float arg2 ;
67638   bool arg3 ;
67639   unsigned int result;
67640
67641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67642   arg2 = (float)jarg2;
67643   arg3 = jarg3 ? true : false;
67644   {
67645     try {
67646       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67647     } catch (std::out_of_range& e) {
67648       {
67649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67650       };
67651     } catch (std::exception& e) {
67652       {
67653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67654       };
67655     } catch (...) {
67656       {
67657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67658       };
67659     }
67660   }
67661   jresult = result;
67662   return jresult;
67663 }
67664
67665
67666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67667   unsigned int jresult ;
67668   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67669   unsigned int result;
67670
67671   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67672   {
67673     try {
67674       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67675     } catch (std::out_of_range& e) {
67676       {
67677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67678       };
67679     } catch (std::exception& e) {
67680       {
67681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67682       };
67683     } catch (...) {
67684       {
67685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67686       };
67687     }
67688   }
67689   jresult = result;
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67695   int jresult ;
67696   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67697   Dali::Toolkit::Ruler::RulerType result;
67698
67699   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67700   {
67701     try {
67702       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67703     } catch (std::out_of_range& e) {
67704       {
67705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67706       };
67707     } catch (std::exception& e) {
67708       {
67709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67710       };
67711     } catch (...) {
67712       {
67713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67714       };
67715     }
67716   }
67717   jresult = (int)result;
67718   return jresult;
67719 }
67720
67721
67722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67723   unsigned int jresult ;
67724   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67725   bool result;
67726
67727   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67728   {
67729     try {
67730       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67731     } catch (std::out_of_range& e) {
67732       {
67733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (std::exception& e) {
67736       {
67737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67738       };
67739     } catch (...) {
67740       {
67741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67742       };
67743     }
67744   }
67745   jresult = result;
67746   return jresult;
67747 }
67748
67749
67750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67751   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67752
67753   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67754   {
67755     try {
67756       (arg1)->Enable();
67757     } catch (std::out_of_range& e) {
67758       {
67759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67760       };
67761     } catch (std::exception& e) {
67762       {
67763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67764       };
67765     } catch (...) {
67766       {
67767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67768       };
67769     }
67770   }
67771 }
67772
67773
67774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67775   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67776
67777   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67778   {
67779     try {
67780       (arg1)->Disable();
67781     } catch (std::out_of_range& e) {
67782       {
67783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67784       };
67785     } catch (std::exception& e) {
67786       {
67787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67788       };
67789     } catch (...) {
67790       {
67791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67792       };
67793     }
67794   }
67795 }
67796
67797
67798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67799   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67800   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67801   Dali::Toolkit::RulerDomain *argp2 ;
67802
67803   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67804   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67805   if (!argp2) {
67806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67807     return ;
67808   }
67809   arg2 = *argp2;
67810   {
67811     try {
67812       (arg1)->SetDomain(arg2);
67813     } catch (std::out_of_range& e) {
67814       {
67815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67816       };
67817     } catch (std::exception& e) {
67818       {
67819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67824       };
67825     }
67826   }
67827 }
67828
67829
67830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67831   void * jresult ;
67832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67833   Dali::Toolkit::RulerDomain *result = 0 ;
67834
67835   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67836   {
67837     try {
67838       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67839     } catch (std::out_of_range& e) {
67840       {
67841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67842       };
67843     } catch (std::exception& e) {
67844       {
67845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67846       };
67847     } catch (...) {
67848       {
67849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67850       };
67851     }
67852   }
67853   jresult = (void *)result;
67854   return jresult;
67855 }
67856
67857
67858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67859   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67860
67861   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67862   {
67863     try {
67864       (arg1)->DisableDomain();
67865     } catch (std::out_of_range& e) {
67866       {
67867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67868       };
67869     } catch (std::exception& e) {
67870       {
67871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67872       };
67873     } catch (...) {
67874       {
67875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67876       };
67877     }
67878   }
67879 }
67880
67881
67882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67883   float jresult ;
67884   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67885   float arg2 ;
67886   float arg3 ;
67887   float arg4 ;
67888   float result;
67889
67890   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67891   arg2 = (float)jarg2;
67892   arg3 = (float)jarg3;
67893   arg4 = (float)jarg4;
67894   {
67895     try {
67896       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67897     } catch (std::out_of_range& e) {
67898       {
67899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67900       };
67901     } catch (std::exception& e) {
67902       {
67903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67904       };
67905     } catch (...) {
67906       {
67907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67908       };
67909     }
67910   }
67911   jresult = result;
67912   return jresult;
67913 }
67914
67915
67916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67917   float jresult ;
67918   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67919   float arg2 ;
67920   float arg3 ;
67921   float result;
67922
67923   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67924   arg2 = (float)jarg2;
67925   arg3 = (float)jarg3;
67926   {
67927     try {
67928       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67929     } catch (std::out_of_range& e) {
67930       {
67931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (std::exception& e) {
67934       {
67935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67936       };
67937     } catch (...) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67940       };
67941     }
67942   }
67943   jresult = result;
67944   return jresult;
67945 }
67946
67947
67948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67949   float jresult ;
67950   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67951   float arg2 ;
67952   float result;
67953
67954   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67955   arg2 = (float)jarg2;
67956   {
67957     try {
67958       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67966       };
67967     } catch (...) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67970       };
67971     }
67972   }
67973   jresult = result;
67974   return jresult;
67975 }
67976
67977
67978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67979   float jresult ;
67980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67981   float arg2 ;
67982   float arg3 ;
67983   float arg4 ;
67984   Dali::Toolkit::ClampState *arg5 = 0 ;
67985   float result;
67986
67987   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67988   arg2 = (float)jarg2;
67989   arg3 = (float)jarg3;
67990   arg4 = (float)jarg4;
67991   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67992   if (!arg5) {
67993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67994     return 0;
67995   }
67996   {
67997     try {
67998       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67999     } catch (std::out_of_range& e) {
68000       {
68001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68002       };
68003     } catch (std::exception& e) {
68004       {
68005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68006       };
68007     } catch (...) {
68008       {
68009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68010       };
68011     }
68012   }
68013   jresult = result;
68014   return jresult;
68015 }
68016
68017
68018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68019   float jresult ;
68020   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68021   float arg2 ;
68022   float arg3 ;
68023   float arg4 ;
68024   float arg5 ;
68025   float result;
68026
68027   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68028   arg2 = (float)jarg2;
68029   arg3 = (float)jarg3;
68030   arg4 = (float)jarg4;
68031   arg5 = (float)jarg5;
68032   {
68033     try {
68034       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68035     } catch (std::out_of_range& e) {
68036       {
68037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68038       };
68039     } catch (std::exception& e) {
68040       {
68041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68042       };
68043     } catch (...) {
68044       {
68045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68046       };
68047     }
68048   }
68049   jresult = result;
68050   return jresult;
68051 }
68052
68053
68054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68055   float jresult ;
68056   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68057   float arg2 ;
68058   float arg3 ;
68059   float arg4 ;
68060   float result;
68061
68062   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68063   arg2 = (float)jarg2;
68064   arg3 = (float)jarg3;
68065   arg4 = (float)jarg4;
68066   {
68067     try {
68068       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68069     } catch (std::out_of_range& e) {
68070       {
68071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68072       };
68073     } catch (std::exception& e) {
68074       {
68075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68076       };
68077     } catch (...) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68080       };
68081     }
68082   }
68083   jresult = result;
68084   return jresult;
68085 }
68086
68087
68088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68089   float jresult ;
68090   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68091   float arg2 ;
68092   float arg3 ;
68093   float result;
68094
68095   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68096   arg2 = (float)jarg2;
68097   arg3 = (float)jarg3;
68098   {
68099     try {
68100       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68101     } catch (std::out_of_range& e) {
68102       {
68103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68104       };
68105     } catch (std::exception& e) {
68106       {
68107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68108       };
68109     } catch (...) {
68110       {
68111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68112       };
68113     }
68114   }
68115   jresult = result;
68116   return jresult;
68117 }
68118
68119
68120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68121   float jresult ;
68122   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68123   float arg2 ;
68124   float result;
68125
68126   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68127   arg2 = (float)jarg2;
68128   {
68129     try {
68130       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68131     } catch (std::out_of_range& e) {
68132       {
68133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68134       };
68135     } catch (std::exception& e) {
68136       {
68137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68138       };
68139     } catch (...) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68142       };
68143     }
68144   }
68145   jresult = result;
68146   return jresult;
68147 }
68148
68149
68150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68151   float jresult ;
68152   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68153   float arg2 ;
68154   float arg3 ;
68155   float arg4 ;
68156   float arg5 ;
68157   Dali::Toolkit::ClampState *arg6 = 0 ;
68158   float result;
68159
68160   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68161   arg2 = (float)jarg2;
68162   arg3 = (float)jarg3;
68163   arg4 = (float)jarg4;
68164   arg5 = (float)jarg5;
68165   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68166   if (!arg6) {
68167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68168     return 0;
68169   }
68170   {
68171     try {
68172       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68173     } catch (std::out_of_range& e) {
68174       {
68175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68176       };
68177     } catch (std::exception& e) {
68178       {
68179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68184       };
68185     }
68186   }
68187   jresult = result;
68188   return jresult;
68189 }
68190
68191
68192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68193   void * jresult ;
68194   Dali::Toolkit::DefaultRuler *result = 0 ;
68195
68196   {
68197     try {
68198       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68199     } catch (std::out_of_range& e) {
68200       {
68201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68202       };
68203     } catch (std::exception& e) {
68204       {
68205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68206       };
68207     } catch (...) {
68208       {
68209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68210       };
68211     }
68212   }
68213   jresult = (void *)result;
68214   return jresult;
68215 }
68216
68217
68218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68219   float jresult ;
68220   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68221   float arg2 ;
68222   float arg3 ;
68223   float result;
68224
68225   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68226   arg2 = (float)jarg2;
68227   arg3 = (float)jarg3;
68228   {
68229     try {
68230       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68231     } catch (std::out_of_range& e) {
68232       {
68233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68234       };
68235     } catch (std::exception& e) {
68236       {
68237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68242       };
68243     }
68244   }
68245   jresult = result;
68246   return jresult;
68247 }
68248
68249
68250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68251   float jresult ;
68252   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68253   unsigned int arg2 ;
68254   unsigned int *arg3 = 0 ;
68255   bool arg4 ;
68256   float result;
68257
68258   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68259   arg2 = (unsigned int)jarg2;
68260   arg3 = (unsigned int *)jarg3;
68261   arg4 = jarg4 ? true : false;
68262   {
68263     try {
68264       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68265     } catch (std::out_of_range& e) {
68266       {
68267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68268       };
68269     } catch (std::exception& e) {
68270       {
68271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68272       };
68273     } catch (...) {
68274       {
68275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68276       };
68277     }
68278   }
68279   jresult = result;
68280   return jresult;
68281 }
68282
68283
68284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68285   unsigned int jresult ;
68286   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68287   float arg2 ;
68288   bool arg3 ;
68289   unsigned int result;
68290
68291   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68292   arg2 = (float)jarg2;
68293   arg3 = jarg3 ? true : false;
68294   {
68295     try {
68296       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68297     } catch (std::out_of_range& e) {
68298       {
68299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68300       };
68301     } catch (std::exception& e) {
68302       {
68303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68304       };
68305     } catch (...) {
68306       {
68307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68308       };
68309     }
68310   }
68311   jresult = result;
68312   return jresult;
68313 }
68314
68315
68316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68317   unsigned int jresult ;
68318   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68319   unsigned int result;
68320
68321   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68322   {
68323     try {
68324       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68325     } catch (std::out_of_range& e) {
68326       {
68327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68328       };
68329     } catch (std::exception& e) {
68330       {
68331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68332       };
68333     } catch (...) {
68334       {
68335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68336       };
68337     }
68338   }
68339   jresult = result;
68340   return jresult;
68341 }
68342
68343
68344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68345   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68346
68347   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68348   {
68349     try {
68350       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68369   void * jresult ;
68370   float arg1 ;
68371   Dali::Toolkit::FixedRuler *result = 0 ;
68372
68373   arg1 = (float)jarg1;
68374   {
68375     try {
68376       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
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 = (void *)result;
68392   return jresult;
68393 }
68394
68395
68396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68397   void * jresult ;
68398   Dali::Toolkit::FixedRuler *result = 0 ;
68399
68400   {
68401     try {
68402       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68403     } catch (std::out_of_range& e) {
68404       {
68405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68406       };
68407     } catch (std::exception& e) {
68408       {
68409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68410       };
68411     } catch (...) {
68412       {
68413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68414       };
68415     }
68416   }
68417   jresult = (void *)result;
68418   return jresult;
68419 }
68420
68421
68422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68423   float jresult ;
68424   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68425   float arg2 ;
68426   float arg3 ;
68427   float result;
68428
68429   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68430   arg2 = (float)jarg2;
68431   arg3 = (float)jarg3;
68432   {
68433     try {
68434       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68435     } catch (std::out_of_range& e) {
68436       {
68437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68438       };
68439     } catch (std::exception& e) {
68440       {
68441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68442       };
68443     } catch (...) {
68444       {
68445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68446       };
68447     }
68448   }
68449   jresult = result;
68450   return jresult;
68451 }
68452
68453
68454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68455   float jresult ;
68456   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68457   unsigned int arg2 ;
68458   unsigned int *arg3 = 0 ;
68459   bool arg4 ;
68460   float result;
68461
68462   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68463   arg2 = (unsigned int)jarg2;
68464   arg3 = (unsigned int *)jarg3;
68465   arg4 = jarg4 ? true : false;
68466   {
68467     try {
68468       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68469     } catch (std::out_of_range& e) {
68470       {
68471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68472       };
68473     } catch (std::exception& e) {
68474       {
68475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68476       };
68477     } catch (...) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68480       };
68481     }
68482   }
68483   jresult = result;
68484   return jresult;
68485 }
68486
68487
68488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68489   unsigned int jresult ;
68490   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68491   float arg2 ;
68492   bool arg3 ;
68493   unsigned int result;
68494
68495   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68496   arg2 = (float)jarg2;
68497   arg3 = jarg3 ? true : false;
68498   {
68499     try {
68500       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68501     } catch (std::out_of_range& e) {
68502       {
68503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68504       };
68505     } catch (std::exception& e) {
68506       {
68507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68508       };
68509     } catch (...) {
68510       {
68511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68512       };
68513     }
68514   }
68515   jresult = result;
68516   return jresult;
68517 }
68518
68519
68520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68521   unsigned int jresult ;
68522   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68523   unsigned int result;
68524
68525   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68526   {
68527     try {
68528       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68529     } catch (std::out_of_range& e) {
68530       {
68531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (std::exception& e) {
68534       {
68535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68536       };
68537     } catch (...) {
68538       {
68539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68540       };
68541     }
68542   }
68543   jresult = result;
68544   return jresult;
68545 }
68546
68547
68548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68549   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68550
68551   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68552   {
68553     try {
68554       delete arg1;
68555     } catch (std::out_of_range& e) {
68556       {
68557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68558       };
68559     } catch (std::exception& e) {
68560       {
68561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68562       };
68563     } catch (...) {
68564       {
68565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68566       };
68567     }
68568   }
68569 }
68570
68571
68572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68573   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68574   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68575
68576   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68577   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68578   if (arg1) (arg1)->scale = *arg2;
68579 }
68580
68581
68582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68583   void * jresult ;
68584   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68585   Dali::Toolkit::ClampState2D *result = 0 ;
68586
68587   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68588   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68589   jresult = (void *)result;
68590   return jresult;
68591 }
68592
68593
68594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68595   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68596   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68597
68598   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68599   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68600   if (arg1) (arg1)->position = *arg2;
68601 }
68602
68603
68604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68605   void * jresult ;
68606   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68607   Dali::Toolkit::ClampState2D *result = 0 ;
68608
68609   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68610   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68611   jresult = (void *)result;
68612   return jresult;
68613 }
68614
68615
68616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68617   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68618   Dali::Toolkit::ClampState arg2 ;
68619
68620   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68621   arg2 = (Dali::Toolkit::ClampState)jarg2;
68622   if (arg1) (arg1)->rotation = arg2;
68623 }
68624
68625
68626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68627   int jresult ;
68628   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68629   Dali::Toolkit::ClampState result;
68630
68631   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68632   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68633   jresult = (int)result;
68634   return jresult;
68635 }
68636
68637
68638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68639   void * jresult ;
68640   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68641
68642   {
68643     try {
68644       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68645     } catch (std::out_of_range& e) {
68646       {
68647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68648       };
68649     } catch (std::exception& e) {
68650       {
68651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68652       };
68653     } catch (...) {
68654       {
68655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68656       };
68657     }
68658   }
68659   jresult = (void *)result;
68660   return jresult;
68661 }
68662
68663
68664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68665   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68666
68667   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68668   {
68669     try {
68670       delete arg1;
68671     } catch (std::out_of_range& e) {
68672       {
68673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68674       };
68675     } catch (std::exception& e) {
68676       {
68677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68678       };
68679     } catch (...) {
68680       {
68681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68682       };
68683     }
68684   }
68685 }
68686
68687
68688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68689   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68690   Dali::Toolkit::SnapType arg2 ;
68691
68692   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68693   arg2 = (Dali::Toolkit::SnapType)jarg2;
68694   if (arg1) (arg1)->type = arg2;
68695 }
68696
68697
68698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68699   int jresult ;
68700   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68701   Dali::Toolkit::SnapType result;
68702
68703   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68704   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68705   jresult = (int)result;
68706   return jresult;
68707 }
68708
68709
68710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68711   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68712   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68713
68714   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68715   arg2 = (Dali::Vector2 *)jarg2;
68716   if (arg1) (arg1)->position = *arg2;
68717 }
68718
68719
68720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68721   void * jresult ;
68722   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68723   Dali::Vector2 *result = 0 ;
68724
68725   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68726   result = (Dali::Vector2 *)& ((arg1)->position);
68727   jresult = (void *)result;
68728   return jresult;
68729 }
68730
68731
68732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68733   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68734   float arg2 ;
68735
68736   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68737   arg2 = (float)jarg2;
68738   if (arg1) (arg1)->duration = arg2;
68739 }
68740
68741
68742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68743   float jresult ;
68744   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68745   float result;
68746
68747   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68748   result = (float) ((arg1)->duration);
68749   jresult = result;
68750   return jresult;
68751 }
68752
68753
68754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68755   void * jresult ;
68756   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68757
68758   {
68759     try {
68760       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68761     } catch (std::out_of_range& e) {
68762       {
68763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (std::exception& e) {
68766       {
68767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68768       };
68769     } catch (...) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68772       };
68773     }
68774   }
68775   jresult = (void *)result;
68776   return jresult;
68777 }
68778
68779
68780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68781   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68782
68783   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68784   {
68785     try {
68786       delete arg1;
68787     } catch (std::out_of_range& e) {
68788       {
68789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68790       };
68791     } catch (std::exception& e) {
68792       {
68793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68794       };
68795     } catch (...) {
68796       {
68797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68798       };
68799     }
68800   }
68801 }
68802
68803
68804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68805   int jresult ;
68806   int result;
68807
68808   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68809   jresult = (int)result;
68810   return jresult;
68811 }
68812
68813
68814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68815   int jresult ;
68816   int result;
68817
68818   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68819   jresult = (int)result;
68820   return jresult;
68821 }
68822
68823
68824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68825   int jresult ;
68826   int result;
68827
68828   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68829   jresult = (int)result;
68830   return jresult;
68831 }
68832
68833
68834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68835   int jresult ;
68836   int result;
68837
68838   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68839   jresult = (int)result;
68840   return jresult;
68841 }
68842
68843
68844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68845   int jresult ;
68846   int result;
68847
68848   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
68849   jresult = (int)result;
68850   return jresult;
68851 }
68852
68853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68854   int jresult ;
68855   int result;
68856
68857   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68858   jresult = (int)result;
68859   return jresult;
68860 }
68861
68862
68863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68864   int jresult ;
68865   int result;
68866
68867   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68868   jresult = (int)result;
68869   return jresult;
68870 }
68871
68872
68873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68874   int jresult ;
68875   int result;
68876
68877   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68878   jresult = (int)result;
68879   return jresult;
68880 }
68881
68882
68883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68884   int jresult ;
68885   int result;
68886
68887   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68888   jresult = (int)result;
68889   return jresult;
68890 }
68891
68892
68893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68894   int jresult ;
68895   int result;
68896
68897   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68898   jresult = (int)result;
68899   return jresult;
68900 }
68901
68902
68903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68904   int jresult ;
68905   int result;
68906
68907   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68908   jresult = (int)result;
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68914   int jresult ;
68915   int result;
68916
68917   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68918   jresult = (int)result;
68919   return jresult;
68920 }
68921
68922
68923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68924   int jresult ;
68925   int result;
68926
68927   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68928   jresult = (int)result;
68929   return jresult;
68930 }
68931
68932
68933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68934   int jresult ;
68935   int result;
68936
68937   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68938   jresult = (int)result;
68939   return jresult;
68940 }
68941
68942
68943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68944   int jresult ;
68945   int result;
68946
68947   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68948   jresult = (int)result;
68949   return jresult;
68950 }
68951
68952
68953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68954   int jresult ;
68955   int result;
68956
68957   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
68958   jresult = (int)result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
68964   int jresult ;
68965   int result;
68966
68967   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
68968   jresult = (int)result;
68969   return jresult;
68970 }
68971
68972
68973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
68974   int jresult ;
68975   int result;
68976
68977   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
68978   jresult = (int)result;
68979   return jresult;
68980 }
68981
68982
68983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
68984   int jresult ;
68985   int result;
68986
68987   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
68988   jresult = (int)result;
68989   return jresult;
68990 }
68991
68992
68993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
68994   int jresult ;
68995   int result;
68996
68997   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
68998   jresult = (int)result;
68999   return jresult;
69000 }
69001
69002
69003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69004   int jresult ;
69005   int result;
69006
69007   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69008   jresult = (int)result;
69009   return jresult;
69010 }
69011
69012
69013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69014   int jresult ;
69015   int result;
69016
69017   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69018   jresult = (int)result;
69019   return jresult;
69020 }
69021
69022
69023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69024   int jresult ;
69025   int result;
69026
69027   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69028   jresult = (int)result;
69029   return jresult;
69030 }
69031
69032
69033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69034   int jresult ;
69035   int result;
69036
69037   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69038   jresult = (int)result;
69039   return jresult;
69040 }
69041
69042
69043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69044   int jresult ;
69045   int result;
69046
69047   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69048   jresult = (int)result;
69049   return jresult;
69050 }
69051
69052
69053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69054   int jresult ;
69055   int result;
69056
69057   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69058   jresult = (int)result;
69059   return jresult;
69060 }
69061
69062
69063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69064   void * jresult ;
69065   Dali::Toolkit::ScrollView::Property *result = 0 ;
69066
69067   {
69068     try {
69069       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69070     } catch (std::out_of_range& e) {
69071       {
69072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69073       };
69074     } catch (std::exception& e) {
69075       {
69076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69077       };
69078     } catch (...) {
69079       {
69080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69081       };
69082     }
69083   }
69084   jresult = (void *)result;
69085   return jresult;
69086 }
69087
69088
69089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69090   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69091
69092   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69093   {
69094     try {
69095       delete arg1;
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69103       };
69104     } catch (...) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69107       };
69108     }
69109   }
69110 }
69111
69112
69113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69114   void * jresult ;
69115   Dali::Toolkit::ScrollView *result = 0 ;
69116
69117   {
69118     try {
69119       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69120     } catch (std::out_of_range& e) {
69121       {
69122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69123       };
69124     } catch (std::exception& e) {
69125       {
69126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (...) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69131       };
69132     }
69133   }
69134   jresult = (void *)result;
69135   return jresult;
69136 }
69137
69138
69139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69140   void * jresult ;
69141   Dali::Toolkit::ScrollView *arg1 = 0 ;
69142   Dali::Toolkit::ScrollView *result = 0 ;
69143
69144   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69145   if (!arg1) {
69146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69147     return 0;
69148   }
69149   {
69150     try {
69151       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69152     } catch (std::out_of_range& e) {
69153       {
69154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69155       };
69156     } catch (std::exception& e) {
69157       {
69158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69159       };
69160     } catch (...) {
69161       {
69162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69163       };
69164     }
69165   }
69166   jresult = (void *)result;
69167   return jresult;
69168 }
69169
69170
69171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69172   void * jresult ;
69173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69174   Dali::Toolkit::ScrollView *arg2 = 0 ;
69175   Dali::Toolkit::ScrollView *result = 0 ;
69176
69177   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69178   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69179   if (!arg2) {
69180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69181     return 0;
69182   }
69183   {
69184     try {
69185       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69186     } catch (std::out_of_range& e) {
69187       {
69188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69189       };
69190     } catch (std::exception& e) {
69191       {
69192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69193       };
69194     } catch (...) {
69195       {
69196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69197       };
69198     }
69199   }
69200   jresult = (void *)result;
69201   return jresult;
69202 }
69203
69204
69205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69207
69208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69209   {
69210     try {
69211       delete arg1;
69212     } catch (std::out_of_range& e) {
69213       {
69214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69215       };
69216     } catch (std::exception& e) {
69217       {
69218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69219       };
69220     } catch (...) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69223       };
69224     }
69225   }
69226 }
69227
69228
69229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69230   void * jresult ;
69231   Dali::Toolkit::ScrollView result;
69232
69233   {
69234     try {
69235       result = Dali::Toolkit::ScrollView::New();
69236     } catch (std::out_of_range& e) {
69237       {
69238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69239       };
69240     } catch (std::exception& e) {
69241       {
69242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (...) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69247       };
69248     }
69249   }
69250   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69251   return jresult;
69252 }
69253
69254
69255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69256   void * jresult ;
69257   Dali::BaseHandle arg1 ;
69258   Dali::BaseHandle *argp1 ;
69259   Dali::Toolkit::ScrollView result;
69260
69261   argp1 = (Dali::BaseHandle *)jarg1;
69262   if (!argp1) {
69263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69264     return 0;
69265   }
69266   arg1 = *argp1;
69267   {
69268     try {
69269       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69270     } catch (std::out_of_range& e) {
69271       {
69272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69273       };
69274     } catch (std::exception& e) {
69275       {
69276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (...) {
69279       {
69280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69281       };
69282     }
69283   }
69284   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69285   return jresult;
69286 }
69287
69288
69289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69290   void * jresult ;
69291   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69292   Dali::AlphaFunction result;
69293
69294   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69295   {
69296     try {
69297       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69298     } catch (std::out_of_range& e) {
69299       {
69300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69301       };
69302     } catch (std::exception& e) {
69303       {
69304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69305       };
69306     } catch (...) {
69307       {
69308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69309       };
69310     }
69311   }
69312   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69313   return jresult;
69314 }
69315
69316
69317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69319   Dali::AlphaFunction arg2 ;
69320   Dali::AlphaFunction *argp2 ;
69321
69322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69323   argp2 = (Dali::AlphaFunction *)jarg2;
69324   if (!argp2) {
69325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69326     return ;
69327   }
69328   arg2 = *argp2;
69329   {
69330     try {
69331       (arg1)->SetScrollSnapAlphaFunction(arg2);
69332     } catch (std::out_of_range& e) {
69333       {
69334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69335       };
69336     } catch (std::exception& e) {
69337       {
69338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69339       };
69340     } catch (...) {
69341       {
69342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69343       };
69344     }
69345   }
69346 }
69347
69348
69349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69350   void * jresult ;
69351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69352   Dali::AlphaFunction result;
69353
69354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69355   {
69356     try {
69357       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69358     } catch (std::out_of_range& e) {
69359       {
69360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69361       };
69362     } catch (std::exception& e) {
69363       {
69364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69365       };
69366     } catch (...) {
69367       {
69368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69369       };
69370     }
69371   }
69372   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69373   return jresult;
69374 }
69375
69376
69377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69379   Dali::AlphaFunction arg2 ;
69380   Dali::AlphaFunction *argp2 ;
69381
69382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69383   argp2 = (Dali::AlphaFunction *)jarg2;
69384   if (!argp2) {
69385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69386     return ;
69387   }
69388   arg2 = *argp2;
69389   {
69390     try {
69391       (arg1)->SetScrollFlickAlphaFunction(arg2);
69392     } catch (std::out_of_range& e) {
69393       {
69394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69395       };
69396     } catch (std::exception& e) {
69397       {
69398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69399       };
69400     } catch (...) {
69401       {
69402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69403       };
69404     }
69405   }
69406 }
69407
69408
69409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69410   float jresult ;
69411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69412   float result;
69413
69414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69415   {
69416     try {
69417       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69418     } catch (std::out_of_range& e) {
69419       {
69420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69421       };
69422     } catch (std::exception& e) {
69423       {
69424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69425       };
69426     } catch (...) {
69427       {
69428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69429       };
69430     }
69431   }
69432   jresult = result;
69433   return jresult;
69434 }
69435
69436
69437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69439   float arg2 ;
69440
69441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69442   arg2 = (float)jarg2;
69443   {
69444     try {
69445       (arg1)->SetScrollSnapDuration(arg2);
69446     } catch (std::out_of_range& e) {
69447       {
69448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69449       };
69450     } catch (std::exception& e) {
69451       {
69452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69453       };
69454     } catch (...) {
69455       {
69456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69457       };
69458     }
69459   }
69460 }
69461
69462
69463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69464   float jresult ;
69465   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69466   float result;
69467
69468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69469   {
69470     try {
69471       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69472     } catch (std::out_of_range& e) {
69473       {
69474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69475       };
69476     } catch (std::exception& e) {
69477       {
69478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69479       };
69480     } catch (...) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69483       };
69484     }
69485   }
69486   jresult = result;
69487   return jresult;
69488 }
69489
69490
69491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69493   float arg2 ;
69494
69495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69496   arg2 = (float)jarg2;
69497   {
69498     try {
69499       (arg1)->SetScrollFlickDuration(arg2);
69500     } catch (std::out_of_range& e) {
69501       {
69502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69503       };
69504     } catch (std::exception& e) {
69505       {
69506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69507       };
69508     } catch (...) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69511       };
69512     }
69513   }
69514 }
69515
69516
69517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69519   Dali::Toolkit::RulerPtr arg2 ;
69520   Dali::Toolkit::RulerPtr *argp2 ;
69521
69522   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69523   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69524   if (!argp2) {
69525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69526     return ;
69527   }
69528   arg2 = *argp2;
69529   {
69530     try {
69531       (arg1)->SetRulerX(arg2);
69532     } catch (std::out_of_range& e) {
69533       {
69534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69535       };
69536     } catch (std::exception& e) {
69537       {
69538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69539       };
69540     } catch (...) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69543       };
69544     }
69545   }
69546 }
69547
69548
69549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69551   Dali::Toolkit::RulerPtr arg2 ;
69552   Dali::Toolkit::RulerPtr *argp2 ;
69553
69554   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69555   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69556   if (!argp2) {
69557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69558     return ;
69559   }
69560   arg2 = *argp2;
69561   {
69562     try {
69563       (arg1)->SetRulerY(arg2);
69564     } catch (std::out_of_range& e) {
69565       {
69566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69567       };
69568     } catch (std::exception& e) {
69569       {
69570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69571       };
69572     } catch (...) {
69573       {
69574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69575       };
69576     }
69577   }
69578 }
69579
69580
69581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69583   bool arg2 ;
69584
69585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69586   arg2 = jarg2 ? true : false;
69587   {
69588     try {
69589       (arg1)->SetScrollSensitive(arg2);
69590     } catch (std::out_of_range& e) {
69591       {
69592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69593       };
69594     } catch (std::exception& e) {
69595       {
69596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69597       };
69598     } catch (...) {
69599       {
69600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69601       };
69602     }
69603   }
69604 }
69605
69606
69607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69609   float arg2 ;
69610   float arg3 ;
69611
69612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69613   arg2 = (float)jarg2;
69614   arg3 = (float)jarg3;
69615   {
69616     try {
69617       (arg1)->SetMaxOvershoot(arg2,arg3);
69618     } catch (std::out_of_range& e) {
69619       {
69620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69621       };
69622     } catch (std::exception& e) {
69623       {
69624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69625       };
69626     } catch (...) {
69627       {
69628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69629       };
69630     }
69631   }
69632 }
69633
69634
69635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69636   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69637   Dali::AlphaFunction arg2 ;
69638   Dali::AlphaFunction *argp2 ;
69639
69640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69641   argp2 = (Dali::AlphaFunction *)jarg2;
69642   if (!argp2) {
69643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69644     return ;
69645   }
69646   arg2 = *argp2;
69647   {
69648     try {
69649       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69650     } catch (std::out_of_range& e) {
69651       {
69652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69653       };
69654     } catch (std::exception& e) {
69655       {
69656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69657       };
69658     } catch (...) {
69659       {
69660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69661       };
69662     }
69663   }
69664 }
69665
69666
69667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69669   float arg2 ;
69670
69671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69672   arg2 = (float)jarg2;
69673   {
69674     try {
69675       (arg1)->SetSnapOvershootDuration(arg2);
69676     } catch (std::out_of_range& e) {
69677       {
69678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69679       };
69680     } catch (std::exception& e) {
69681       {
69682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69683       };
69684     } catch (...) {
69685       {
69686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69687       };
69688     }
69689   }
69690 }
69691
69692
69693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69694   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69695   bool arg2 ;
69696
69697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69698   arg2 = jarg2 ? true : false;
69699   {
69700     try {
69701       (arg1)->SetActorAutoSnap(arg2);
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69709       };
69710     } catch (...) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69713       };
69714     }
69715   }
69716 }
69717
69718
69719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69721   bool arg2 ;
69722
69723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69724   arg2 = jarg2 ? true : false;
69725   {
69726     try {
69727       (arg1)->SetWrapMode(arg2);
69728     } catch (std::out_of_range& e) {
69729       {
69730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69731       };
69732     } catch (std::exception& e) {
69733       {
69734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69735       };
69736     } catch (...) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69739       };
69740     }
69741   }
69742 }
69743
69744
69745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69746   int jresult ;
69747   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69748   int result;
69749
69750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69751   {
69752     try {
69753       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69754     } catch (std::out_of_range& e) {
69755       {
69756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69757       };
69758     } catch (std::exception& e) {
69759       {
69760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69761       };
69762     } catch (...) {
69763       {
69764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69765       };
69766     }
69767   }
69768   jresult = result;
69769   return jresult;
69770 }
69771
69772
69773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69775   int arg2 ;
69776
69777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69778   arg2 = (int)jarg2;
69779   {
69780     try {
69781       (arg1)->SetScrollUpdateDistance(arg2);
69782     } catch (std::out_of_range& e) {
69783       {
69784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69785       };
69786     } catch (std::exception& e) {
69787       {
69788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69789       };
69790     } catch (...) {
69791       {
69792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69793       };
69794     }
69795   }
69796 }
69797
69798
69799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69800   unsigned int jresult ;
69801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69802   bool result;
69803
69804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69805   {
69806     try {
69807       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822   jresult = result;
69823   return jresult;
69824 }
69825
69826
69827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69829   bool arg2 ;
69830
69831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69832   arg2 = jarg2 ? true : false;
69833   {
69834     try {
69835       (arg1)->SetAxisAutoLock(arg2);
69836     } catch (std::out_of_range& e) {
69837       {
69838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69839       };
69840     } catch (std::exception& e) {
69841       {
69842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69843       };
69844     } catch (...) {
69845       {
69846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69847       };
69848     }
69849   }
69850 }
69851
69852
69853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69854   float jresult ;
69855   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69856   float result;
69857
69858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69859   {
69860     try {
69861       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69862     } catch (std::out_of_range& e) {
69863       {
69864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69865       };
69866     } catch (std::exception& e) {
69867       {
69868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69869       };
69870     } catch (...) {
69871       {
69872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69873       };
69874     }
69875   }
69876   jresult = result;
69877   return jresult;
69878 }
69879
69880
69881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69883   float arg2 ;
69884
69885   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69886   arg2 = (float)jarg2;
69887   {
69888     try {
69889       (arg1)->SetAxisAutoLockGradient(arg2);
69890     } catch (std::out_of_range& e) {
69891       {
69892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69893       };
69894     } catch (std::exception& e) {
69895       {
69896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69897       };
69898     } catch (...) {
69899       {
69900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69901       };
69902     }
69903   }
69904 }
69905
69906
69907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69908   float jresult ;
69909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69910   float result;
69911
69912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69913   {
69914     try {
69915       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69916     } catch (std::out_of_range& e) {
69917       {
69918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (std::exception& e) {
69921       {
69922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69927       };
69928     }
69929   }
69930   jresult = result;
69931   return jresult;
69932 }
69933
69934
69935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69936   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69937   float arg2 ;
69938
69939   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69940   arg2 = (float)jarg2;
69941   {
69942     try {
69943       (arg1)->SetFrictionCoefficient(arg2);
69944     } catch (std::out_of_range& e) {
69945       {
69946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69947       };
69948     } catch (std::exception& e) {
69949       {
69950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69951       };
69952     } catch (...) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69955       };
69956     }
69957   }
69958 }
69959
69960
69961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
69962   float jresult ;
69963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69964   float result;
69965
69966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69967   {
69968     try {
69969       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
69970     } catch (std::out_of_range& e) {
69971       {
69972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69973       };
69974     } catch (std::exception& e) {
69975       {
69976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69977       };
69978     } catch (...) {
69979       {
69980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69981       };
69982     }
69983   }
69984   jresult = result;
69985   return jresult;
69986 }
69987
69988
69989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
69990   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69991   float arg2 ;
69992
69993   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69994   arg2 = (float)jarg2;
69995   {
69996     try {
69997       (arg1)->SetFlickSpeedCoefficient(arg2);
69998     } catch (std::out_of_range& e) {
69999       {
70000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70001       };
70002     } catch (std::exception& e) {
70003       {
70004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70005       };
70006     } catch (...) {
70007       {
70008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70009       };
70010     }
70011   }
70012 }
70013
70014
70015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70016   void * jresult ;
70017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70018   Dali::Vector2 result;
70019
70020   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70021   {
70022     try {
70023       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70024     } catch (std::out_of_range& e) {
70025       {
70026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70027       };
70028     } catch (std::exception& e) {
70029       {
70030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70031       };
70032     } catch (...) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70035       };
70036     }
70037   }
70038   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70039   return jresult;
70040 }
70041
70042
70043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70045   Dali::Vector2 *arg2 = 0 ;
70046
70047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70048   arg2 = (Dali::Vector2 *)jarg2;
70049   if (!arg2) {
70050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70051     return ;
70052   }
70053   {
70054     try {
70055       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70056     } catch (std::out_of_range& e) {
70057       {
70058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70059       };
70060     } catch (std::exception& e) {
70061       {
70062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70063       };
70064     } catch (...) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70067       };
70068     }
70069   }
70070 }
70071
70072
70073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70074   float jresult ;
70075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70076   float result;
70077
70078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70079   {
70080     try {
70081       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70082     } catch (std::out_of_range& e) {
70083       {
70084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (std::exception& e) {
70087       {
70088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (...) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70093       };
70094     }
70095   }
70096   jresult = result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70102   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70103   float arg2 ;
70104
70105   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70106   arg2 = (float)jarg2;
70107   {
70108     try {
70109       (arg1)->SetMinimumSpeedForFlick(arg2);
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70117       };
70118     } catch (...) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70121       };
70122     }
70123   }
70124 }
70125
70126
70127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70128   float jresult ;
70129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70130   float result;
70131
70132   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70133   {
70134     try {
70135       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70136     } catch (std::out_of_range& e) {
70137       {
70138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70139       };
70140     } catch (std::exception& e) {
70141       {
70142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (...) {
70145       {
70146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70147       };
70148     }
70149   }
70150   jresult = result;
70151   return jresult;
70152 }
70153
70154
70155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70156   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70157   float arg2 ;
70158
70159   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70160   arg2 = (float)jarg2;
70161   {
70162     try {
70163       (arg1)->SetMaxFlickSpeed(arg2);
70164     } catch (std::out_of_range& e) {
70165       {
70166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70167       };
70168     } catch (std::exception& e) {
70169       {
70170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70171       };
70172     } catch (...) {
70173       {
70174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70175       };
70176     }
70177   }
70178 }
70179
70180
70181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70182   void * jresult ;
70183   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70184   Dali::Vector2 result;
70185
70186   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70187   {
70188     try {
70189       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70190     } catch (std::out_of_range& e) {
70191       {
70192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (std::exception& e) {
70195       {
70196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70197       };
70198     } catch (...) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70201       };
70202     }
70203   }
70204   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70205   return jresult;
70206 }
70207
70208
70209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70211   Dali::Vector2 arg2 ;
70212   Dali::Vector2 *argp2 ;
70213
70214   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70215   argp2 = (Dali::Vector2 *)jarg2;
70216   if (!argp2) {
70217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70218     return ;
70219   }
70220   arg2 = *argp2;
70221   {
70222     try {
70223       (arg1)->SetWheelScrollDistanceStep(arg2);
70224     } catch (std::out_of_range& e) {
70225       {
70226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70227       };
70228     } catch (std::exception& e) {
70229       {
70230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70231       };
70232     } catch (...) {
70233       {
70234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70235       };
70236     }
70237   }
70238 }
70239
70240
70241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70242   void * jresult ;
70243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70244   Dali::Vector2 result;
70245
70246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70247   {
70248     try {
70249       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70250     } catch (std::out_of_range& e) {
70251       {
70252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70253       };
70254     } catch (std::exception& e) {
70255       {
70256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70261       };
70262     }
70263   }
70264   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70265   return jresult;
70266 }
70267
70268
70269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70270   unsigned int jresult ;
70271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70272   unsigned int result;
70273
70274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70275   {
70276     try {
70277       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70278     } catch (std::out_of_range& e) {
70279       {
70280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (std::exception& e) {
70283       {
70284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (...) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70289       };
70290     }
70291   }
70292   jresult = result;
70293   return jresult;
70294 }
70295
70296
70297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70299   Dali::Vector2 *arg2 = 0 ;
70300
70301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70302   arg2 = (Dali::Vector2 *)jarg2;
70303   if (!arg2) {
70304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70305     return ;
70306   }
70307   {
70308     try {
70309       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70310     } catch (std::out_of_range& e) {
70311       {
70312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70313       };
70314     } catch (std::exception& e) {
70315       {
70316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70317       };
70318     } catch (...) {
70319       {
70320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70321       };
70322     }
70323   }
70324 }
70325
70326
70327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70329   Dali::Vector2 *arg2 = 0 ;
70330   float arg3 ;
70331
70332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70333   arg2 = (Dali::Vector2 *)jarg2;
70334   if (!arg2) {
70335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70336     return ;
70337   }
70338   arg3 = (float)jarg3;
70339   {
70340     try {
70341       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70342     } catch (std::out_of_range& e) {
70343       {
70344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70345       };
70346     } catch (std::exception& e) {
70347       {
70348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70349       };
70350     } catch (...) {
70351       {
70352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70353       };
70354     }
70355   }
70356 }
70357
70358
70359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70361   Dali::Vector2 *arg2 = 0 ;
70362   float arg3 ;
70363   Dali::AlphaFunction arg4 ;
70364   Dali::AlphaFunction *argp4 ;
70365
70366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70367   arg2 = (Dali::Vector2 *)jarg2;
70368   if (!arg2) {
70369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70370     return ;
70371   }
70372   arg3 = (float)jarg3;
70373   argp4 = (Dali::AlphaFunction *)jarg4;
70374   if (!argp4) {
70375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70376     return ;
70377   }
70378   arg4 = *argp4;
70379   {
70380     try {
70381       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70382     } catch (std::out_of_range& e) {
70383       {
70384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70385       };
70386     } catch (std::exception& e) {
70387       {
70388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70389       };
70390     } catch (...) {
70391       {
70392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70393       };
70394     }
70395   }
70396 }
70397
70398
70399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70401   Dali::Vector2 *arg2 = 0 ;
70402   float arg3 ;
70403   Dali::Toolkit::DirectionBias arg4 ;
70404   Dali::Toolkit::DirectionBias arg5 ;
70405
70406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70407   arg2 = (Dali::Vector2 *)jarg2;
70408   if (!arg2) {
70409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70410     return ;
70411   }
70412   arg3 = (float)jarg3;
70413   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70414   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70415   {
70416     try {
70417       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70425       };
70426     } catch (...) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70429       };
70430     }
70431   }
70432 }
70433
70434
70435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70437   Dali::Vector2 *arg2 = 0 ;
70438   float arg3 ;
70439   Dali::AlphaFunction arg4 ;
70440   Dali::Toolkit::DirectionBias arg5 ;
70441   Dali::Toolkit::DirectionBias arg6 ;
70442   Dali::AlphaFunction *argp4 ;
70443
70444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70445   arg2 = (Dali::Vector2 *)jarg2;
70446   if (!arg2) {
70447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70448     return ;
70449   }
70450   arg3 = (float)jarg3;
70451   argp4 = (Dali::AlphaFunction *)jarg4;
70452   if (!argp4) {
70453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70454     return ;
70455   }
70456   arg4 = *argp4;
70457   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70458   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70459   {
70460     try {
70461       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70462     } catch (std::out_of_range& e) {
70463       {
70464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (std::exception& e) {
70467       {
70468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70473       };
70474     }
70475   }
70476 }
70477
70478
70479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70481   unsigned int arg2 ;
70482
70483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70484   arg2 = (unsigned int)jarg2;
70485   {
70486     try {
70487       (arg1)->ScrollTo(arg2);
70488     } catch (std::out_of_range& e) {
70489       {
70490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70491       };
70492     } catch (std::exception& e) {
70493       {
70494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70495       };
70496     } catch (...) {
70497       {
70498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70499       };
70500     }
70501   }
70502 }
70503
70504
70505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70507   unsigned int arg2 ;
70508   float arg3 ;
70509
70510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70511   arg2 = (unsigned int)jarg2;
70512   arg3 = (float)jarg3;
70513   {
70514     try {
70515       (arg1)->ScrollTo(arg2,arg3);
70516     } catch (std::out_of_range& e) {
70517       {
70518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70519       };
70520     } catch (std::exception& e) {
70521       {
70522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70523       };
70524     } catch (...) {
70525       {
70526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70527       };
70528     }
70529   }
70530 }
70531
70532
70533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70534   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70535   unsigned int arg2 ;
70536   float arg3 ;
70537   Dali::Toolkit::DirectionBias arg4 ;
70538
70539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70540   arg2 = (unsigned int)jarg2;
70541   arg3 = (float)jarg3;
70542   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70543   {
70544     try {
70545       (arg1)->ScrollTo(arg2,arg3,arg4);
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70553       };
70554     } catch (...) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70557       };
70558     }
70559   }
70560 }
70561
70562
70563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70564   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70565   Dali::Actor *arg2 = 0 ;
70566
70567   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70568   arg2 = (Dali::Actor *)jarg2;
70569   if (!arg2) {
70570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70571     return ;
70572   }
70573   {
70574     try {
70575       (arg1)->ScrollTo(*arg2);
70576     } catch (std::out_of_range& e) {
70577       {
70578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70579       };
70580     } catch (std::exception& e) {
70581       {
70582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70583       };
70584     } catch (...) {
70585       {
70586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70587       };
70588     }
70589   }
70590 }
70591
70592
70593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70595   Dali::Actor *arg2 = 0 ;
70596   float arg3 ;
70597
70598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70599   arg2 = (Dali::Actor *)jarg2;
70600   if (!arg2) {
70601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70602     return ;
70603   }
70604   arg3 = (float)jarg3;
70605   {
70606     try {
70607       (arg1)->ScrollTo(*arg2,arg3);
70608     } catch (std::out_of_range& e) {
70609       {
70610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70611       };
70612     } catch (std::exception& e) {
70613       {
70614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70615       };
70616     } catch (...) {
70617       {
70618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70619       };
70620     }
70621   }
70622 }
70623
70624
70625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70626   unsigned int jresult ;
70627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70628   bool result;
70629
70630   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70631   {
70632     try {
70633       result = (bool)(arg1)->ScrollToSnapPoint();
70634     } catch (std::out_of_range& e) {
70635       {
70636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70637       };
70638     } catch (std::exception& e) {
70639       {
70640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70641       };
70642     } catch (...) {
70643       {
70644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70645       };
70646     }
70647   }
70648   jresult = result;
70649   return jresult;
70650 }
70651
70652
70653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70655   Dali::Constraint arg2 ;
70656   Dali::Constraint *argp2 ;
70657
70658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70659   argp2 = (Dali::Constraint *)jarg2;
70660   if (!argp2) {
70661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70662     return ;
70663   }
70664   arg2 = *argp2;
70665   {
70666     try {
70667       (arg1)->ApplyConstraintToChildren(arg2);
70668     } catch (std::out_of_range& e) {
70669       {
70670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70671       };
70672     } catch (std::exception& e) {
70673       {
70674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70675       };
70676     } catch (...) {
70677       {
70678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70679       };
70680     }
70681   }
70682 }
70683
70684
70685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70686   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70687
70688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70689   {
70690     try {
70691       (arg1)->RemoveConstraintsFromChildren();
70692     } catch (std::out_of_range& e) {
70693       {
70694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70695       };
70696     } catch (std::exception& e) {
70697       {
70698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70699       };
70700     } catch (...) {
70701       {
70702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70703       };
70704     }
70705   }
70706 }
70707
70708
70709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70710   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70711   Dali::Toolkit::ScrollViewEffect arg2 ;
70712   Dali::Toolkit::ScrollViewEffect *argp2 ;
70713
70714   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70715   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70716   if (!argp2) {
70717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70718     return ;
70719   }
70720   arg2 = *argp2;
70721   {
70722     try {
70723       (arg1)->ApplyEffect(arg2);
70724     } catch (std::out_of_range& e) {
70725       {
70726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70727       };
70728     } catch (std::exception& e) {
70729       {
70730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70731       };
70732     } catch (...) {
70733       {
70734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70735       };
70736     }
70737   }
70738 }
70739
70740
70741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70742   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70743   Dali::Toolkit::ScrollViewEffect arg2 ;
70744   Dali::Toolkit::ScrollViewEffect *argp2 ;
70745
70746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70747   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70748   if (!argp2) {
70749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70750     return ;
70751   }
70752   arg2 = *argp2;
70753   {
70754     try {
70755       (arg1)->RemoveEffect(arg2);
70756     } catch (std::out_of_range& e) {
70757       {
70758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70759       };
70760     } catch (std::exception& e) {
70761       {
70762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70763       };
70764     } catch (...) {
70765       {
70766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70767       };
70768     }
70769   }
70770 }
70771
70772
70773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70775
70776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70777   {
70778     try {
70779       (arg1)->RemoveAllEffects();
70780     } catch (std::out_of_range& e) {
70781       {
70782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70783       };
70784     } catch (std::exception& e) {
70785       {
70786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70787       };
70788     } catch (...) {
70789       {
70790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70791       };
70792     }
70793   }
70794 }
70795
70796
70797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70799   Dali::Actor arg2 ;
70800   Dali::Actor *argp2 ;
70801
70802   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70803   argp2 = (Dali::Actor *)jarg2;
70804   if (!argp2) {
70805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70806     return ;
70807   }
70808   arg2 = *argp2;
70809   {
70810     try {
70811       (arg1)->BindActor(arg2);
70812     } catch (std::out_of_range& e) {
70813       {
70814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70815       };
70816     } catch (std::exception& e) {
70817       {
70818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70819       };
70820     } catch (...) {
70821       {
70822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70823       };
70824     }
70825   }
70826 }
70827
70828
70829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70830   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70831   Dali::Actor arg2 ;
70832   Dali::Actor *argp2 ;
70833
70834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70835   argp2 = (Dali::Actor *)jarg2;
70836   if (!argp2) {
70837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70838     return ;
70839   }
70840   arg2 = *argp2;
70841   {
70842     try {
70843       (arg1)->UnbindActor(arg2);
70844     } catch (std::out_of_range& e) {
70845       {
70846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70847       };
70848     } catch (std::exception& e) {
70849       {
70850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70851       };
70852     } catch (...) {
70853       {
70854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70855       };
70856     }
70857   }
70858 }
70859
70860
70861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70862   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70863   Dali::Radian arg2 ;
70864   Dali::Radian arg3 ;
70865   Dali::Radian *argp2 ;
70866   Dali::Radian *argp3 ;
70867
70868   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70869   argp2 = (Dali::Radian *)jarg2;
70870   if (!argp2) {
70871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70872     return ;
70873   }
70874   arg2 = *argp2;
70875   argp3 = (Dali::Radian *)jarg3;
70876   if (!argp3) {
70877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70878     return ;
70879   }
70880   arg3 = *argp3;
70881   {
70882     try {
70883       (arg1)->SetScrollingDirection(arg2,arg3);
70884     } catch (std::out_of_range& e) {
70885       {
70886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70887       };
70888     } catch (std::exception& e) {
70889       {
70890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70891       };
70892     } catch (...) {
70893       {
70894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70895       };
70896     }
70897   }
70898 }
70899
70900
70901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70902   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70903   Dali::Radian arg2 ;
70904   Dali::Radian *argp2 ;
70905
70906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70907   argp2 = (Dali::Radian *)jarg2;
70908   if (!argp2) {
70909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70910     return ;
70911   }
70912   arg2 = *argp2;
70913   {
70914     try {
70915       (arg1)->SetScrollingDirection(arg2);
70916     } catch (std::out_of_range& e) {
70917       {
70918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70919       };
70920     } catch (std::exception& e) {
70921       {
70922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70923       };
70924     } catch (...) {
70925       {
70926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70927       };
70928     }
70929   }
70930 }
70931
70932
70933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70935   Dali::Radian arg2 ;
70936   Dali::Radian *argp2 ;
70937
70938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70939   argp2 = (Dali::Radian *)jarg2;
70940   if (!argp2) {
70941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70942     return ;
70943   }
70944   arg2 = *argp2;
70945   {
70946     try {
70947       (arg1)->RemoveScrollingDirection(arg2);
70948     } catch (std::out_of_range& e) {
70949       {
70950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70951       };
70952     } catch (std::exception& e) {
70953       {
70954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70955       };
70956     } catch (...) {
70957       {
70958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70959       };
70960     }
70961   }
70962 }
70963
70964
70965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
70966   void * jresult ;
70967   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70968   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
70969
70970   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70971   {
70972     try {
70973       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
70974     } catch (std::out_of_range& e) {
70975       {
70976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70977       };
70978     } catch (std::exception& e) {
70979       {
70980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70981       };
70982     } catch (...) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70985       };
70986     }
70987   }
70988   jresult = (void *)result;
70989   return jresult;
70990 }
70991
70992
70993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
70994   int jresult ;
70995   int result;
70996
70997   result = (int)Dali::Toolkit::TableView::Property::ROWS;
70998   jresult = (int)result;
70999   return jresult;
71000 }
71001
71002
71003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71004   int jresult ;
71005   int result;
71006
71007   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71008   jresult = (int)result;
71009   return jresult;
71010 }
71011
71012
71013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71014   int jresult ;
71015   int result;
71016
71017   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71018   jresult = (int)result;
71019   return jresult;
71020 }
71021
71022
71023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71024   int jresult ;
71025   int result;
71026
71027   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71028   jresult = (int)result;
71029   return jresult;
71030 }
71031
71032
71033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71034   int jresult ;
71035   int result;
71036
71037   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71038   jresult = (int)result;
71039   return jresult;
71040 }
71041
71042
71043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71044   void * jresult ;
71045   Dali::Toolkit::TableView::Property *result = 0 ;
71046
71047   {
71048     try {
71049       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71050     } catch (std::out_of_range& e) {
71051       {
71052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71053       };
71054     } catch (std::exception& e) {
71055       {
71056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71061       };
71062     }
71063   }
71064   jresult = (void *)result;
71065   return jresult;
71066 }
71067
71068
71069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71070   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71071
71072   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71073   {
71074     try {
71075       delete arg1;
71076     } catch (std::out_of_range& e) {
71077       {
71078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71079       };
71080     } catch (std::exception& e) {
71081       {
71082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71083       };
71084     } catch (...) {
71085       {
71086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71087       };
71088     }
71089   }
71090 }
71091
71092
71093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71094   int jresult ;
71095   int result;
71096
71097   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71098   jresult = (int)result;
71099   return jresult;
71100 }
71101
71102
71103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71104   int jresult ;
71105   int result;
71106
71107   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71108   jresult = (int)result;
71109   return jresult;
71110 }
71111
71112
71113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71114   int jresult ;
71115   int result;
71116
71117   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71118   jresult = (int)result;
71119   return jresult;
71120 }
71121
71122
71123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71124   int jresult ;
71125   int result;
71126
71127   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71128   jresult = (int)result;
71129   return jresult;
71130 }
71131
71132
71133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71134   int jresult ;
71135   int result;
71136
71137   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71138   jresult = (int)result;
71139   return jresult;
71140 }
71141
71142
71143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71144   void * jresult ;
71145   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71146
71147   {
71148     try {
71149       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71150     } catch (std::out_of_range& e) {
71151       {
71152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71153       };
71154     } catch (std::exception& e) {
71155       {
71156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71157       };
71158     } catch (...) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71161       };
71162     }
71163   }
71164   jresult = (void *)result;
71165   return jresult;
71166 }
71167
71168
71169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71170   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71171
71172   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71173   {
71174     try {
71175       delete arg1;
71176     } catch (std::out_of_range& e) {
71177       {
71178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71179       };
71180     } catch (std::exception& e) {
71181       {
71182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71183       };
71184     } catch (...) {
71185       {
71186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71187       };
71188     }
71189   }
71190 }
71191
71192
71193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71194   void * jresult ;
71195   unsigned int arg1 ;
71196   unsigned int arg2 ;
71197   unsigned int arg3 ;
71198   unsigned int arg4 ;
71199   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71200
71201   arg1 = (unsigned int)jarg1;
71202   arg2 = (unsigned int)jarg2;
71203   arg3 = (unsigned int)jarg3;
71204   arg4 = (unsigned int)jarg4;
71205   {
71206     try {
71207       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71208     } catch (std::out_of_range& e) {
71209       {
71210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (std::exception& e) {
71213       {
71214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71215       };
71216     } catch (...) {
71217       {
71218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71219       };
71220     }
71221   }
71222   jresult = (void *)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71228   void * jresult ;
71229   unsigned int arg1 ;
71230   unsigned int arg2 ;
71231   unsigned int arg3 ;
71232   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71233
71234   arg1 = (unsigned int)jarg1;
71235   arg2 = (unsigned int)jarg2;
71236   arg3 = (unsigned int)jarg3;
71237   {
71238     try {
71239       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71240     } catch (std::out_of_range& e) {
71241       {
71242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71243       };
71244     } catch (std::exception& e) {
71245       {
71246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71247       };
71248     } catch (...) {
71249       {
71250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71251       };
71252     }
71253   }
71254   jresult = (void *)result;
71255   return jresult;
71256 }
71257
71258
71259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71260   void * jresult ;
71261   unsigned int arg1 ;
71262   unsigned int arg2 ;
71263   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71264
71265   arg1 = (unsigned int)jarg1;
71266   arg2 = (unsigned int)jarg2;
71267   {
71268     try {
71269       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71270     } catch (std::out_of_range& e) {
71271       {
71272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71273       };
71274     } catch (std::exception& e) {
71275       {
71276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71277       };
71278     } catch (...) {
71279       {
71280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71281       };
71282     }
71283   }
71284   jresult = (void *)result;
71285   return jresult;
71286 }
71287
71288
71289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71290   void * jresult ;
71291   unsigned int arg1 ;
71292   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71293
71294   arg1 = (unsigned int)jarg1;
71295   {
71296     try {
71297       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71298     } catch (std::out_of_range& e) {
71299       {
71300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71301       };
71302     } catch (std::exception& e) {
71303       {
71304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71305       };
71306     } catch (...) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71309       };
71310     }
71311   }
71312   jresult = (void *)result;
71313   return jresult;
71314 }
71315
71316
71317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71318   void * jresult ;
71319   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71320
71321   {
71322     try {
71323       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
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_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71344   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71345   unsigned int arg2 ;
71346
71347   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71348   arg2 = (unsigned int)jarg2;
71349   if (arg1) (arg1)->rowIndex = arg2;
71350 }
71351
71352
71353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71354   unsigned int jresult ;
71355   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71356   unsigned int result;
71357
71358   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71359   result = (unsigned int) ((arg1)->rowIndex);
71360   jresult = result;
71361   return jresult;
71362 }
71363
71364
71365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71366   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71367   unsigned int arg2 ;
71368
71369   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71370   arg2 = (unsigned int)jarg2;
71371   if (arg1) (arg1)->columnIndex = arg2;
71372 }
71373
71374
71375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71376   unsigned int jresult ;
71377   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71378   unsigned int result;
71379
71380   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71381   result = (unsigned int) ((arg1)->columnIndex);
71382   jresult = result;
71383   return jresult;
71384 }
71385
71386
71387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71388   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71389   unsigned int arg2 ;
71390
71391   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71392   arg2 = (unsigned int)jarg2;
71393   if (arg1) (arg1)->rowSpan = arg2;
71394 }
71395
71396
71397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71398   unsigned int jresult ;
71399   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71400   unsigned int result;
71401
71402   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71403   result = (unsigned int) ((arg1)->rowSpan);
71404   jresult = result;
71405   return jresult;
71406 }
71407
71408
71409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71410   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71411   unsigned int arg2 ;
71412
71413   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71414   arg2 = (unsigned int)jarg2;
71415   if (arg1) (arg1)->columnSpan = arg2;
71416 }
71417
71418
71419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71420   unsigned int jresult ;
71421   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71422   unsigned int result;
71423
71424   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71425   result = (unsigned int) ((arg1)->columnSpan);
71426   jresult = result;
71427   return jresult;
71428 }
71429
71430
71431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71432   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71433
71434   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71435   {
71436     try {
71437       delete arg1;
71438     } catch (std::out_of_range& e) {
71439       {
71440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71441       };
71442     } catch (std::exception& e) {
71443       {
71444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71445       };
71446     } catch (...) {
71447       {
71448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71449       };
71450     }
71451   }
71452 }
71453
71454
71455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71456   void * jresult ;
71457   Dali::Toolkit::TableView *result = 0 ;
71458
71459   {
71460     try {
71461       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71462     } catch (std::out_of_range& e) {
71463       {
71464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71465       };
71466     } catch (std::exception& e) {
71467       {
71468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71469       };
71470     } catch (...) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71473       };
71474     }
71475   }
71476   jresult = (void *)result;
71477   return jresult;
71478 }
71479
71480
71481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71482   void * jresult ;
71483   Dali::Toolkit::TableView *arg1 = 0 ;
71484   Dali::Toolkit::TableView *result = 0 ;
71485
71486   arg1 = (Dali::Toolkit::TableView *)jarg1;
71487   if (!arg1) {
71488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71489     return 0;
71490   }
71491   {
71492     try {
71493       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71494     } catch (std::out_of_range& e) {
71495       {
71496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71497       };
71498     } catch (std::exception& e) {
71499       {
71500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71501       };
71502     } catch (...) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71505       };
71506     }
71507   }
71508   jresult = (void *)result;
71509   return jresult;
71510 }
71511
71512
71513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71514   void * jresult ;
71515   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71516   Dali::Toolkit::TableView *arg2 = 0 ;
71517   Dali::Toolkit::TableView *result = 0 ;
71518
71519   arg1 = (Dali::Toolkit::TableView *)jarg1;
71520   arg2 = (Dali::Toolkit::TableView *)jarg2;
71521   if (!arg2) {
71522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71523     return 0;
71524   }
71525   {
71526     try {
71527       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71528     } catch (std::out_of_range& e) {
71529       {
71530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71531       };
71532     } catch (std::exception& e) {
71533       {
71534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71535       };
71536     } catch (...) {
71537       {
71538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71539       };
71540     }
71541   }
71542   jresult = (void *)result;
71543   return jresult;
71544 }
71545
71546
71547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71548   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71549
71550   arg1 = (Dali::Toolkit::TableView *)jarg1;
71551   {
71552     try {
71553       delete arg1;
71554     } catch (std::out_of_range& e) {
71555       {
71556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71557       };
71558     } catch (std::exception& e) {
71559       {
71560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71561       };
71562     } catch (...) {
71563       {
71564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71565       };
71566     }
71567   }
71568 }
71569
71570
71571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71572   void * jresult ;
71573   unsigned int arg1 ;
71574   unsigned int arg2 ;
71575   Dali::Toolkit::TableView result;
71576
71577   arg1 = (unsigned int)jarg1;
71578   arg2 = (unsigned int)jarg2;
71579   {
71580     try {
71581       result = Dali::Toolkit::TableView::New(arg1,arg2);
71582     } catch (std::out_of_range& e) {
71583       {
71584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71585       };
71586     } catch (std::exception& e) {
71587       {
71588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71589       };
71590     } catch (...) {
71591       {
71592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71593       };
71594     }
71595   }
71596   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71597   return jresult;
71598 }
71599
71600
71601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71602   void * jresult ;
71603   Dali::BaseHandle arg1 ;
71604   Dali::BaseHandle *argp1 ;
71605   Dali::Toolkit::TableView result;
71606
71607   argp1 = (Dali::BaseHandle *)jarg1;
71608   if (!argp1) {
71609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71610     return 0;
71611   }
71612   arg1 = *argp1;
71613   {
71614     try {
71615       result = Dali::Toolkit::TableView::DownCast(arg1);
71616     } catch (std::out_of_range& e) {
71617       {
71618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (std::exception& e) {
71621       {
71622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71623       };
71624     } catch (...) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71627       };
71628     }
71629   }
71630   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71631   return jresult;
71632 }
71633
71634
71635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71636   unsigned int jresult ;
71637   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71638   Dali::Actor arg2 ;
71639   Dali::Toolkit::TableView::CellPosition arg3 ;
71640   Dali::Actor *argp2 ;
71641   Dali::Toolkit::TableView::CellPosition *argp3 ;
71642   bool result;
71643
71644   arg1 = (Dali::Toolkit::TableView *)jarg1;
71645   argp2 = (Dali::Actor *)jarg2;
71646   if (!argp2) {
71647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71648     return 0;
71649   }
71650   arg2 = *argp2;
71651   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71652   if (!argp3) {
71653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71654     return 0;
71655   }
71656   arg3 = *argp3;
71657   {
71658     try {
71659       result = (bool)(arg1)->AddChild(arg2,arg3);
71660     } catch (std::out_of_range& e) {
71661       {
71662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71663       };
71664     } catch (std::exception& e) {
71665       {
71666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71667       };
71668     } catch (...) {
71669       {
71670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71671       };
71672     }
71673   }
71674   jresult = result;
71675   return jresult;
71676 }
71677
71678
71679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71680   void * jresult ;
71681   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71682   Dali::Toolkit::TableView::CellPosition arg2 ;
71683   Dali::Toolkit::TableView::CellPosition *argp2 ;
71684   Dali::Actor result;
71685
71686   arg1 = (Dali::Toolkit::TableView *)jarg1;
71687   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71688   if (!argp2) {
71689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71690     return 0;
71691   }
71692   arg2 = *argp2;
71693   {
71694     try {
71695       result = (arg1)->GetChildAt(arg2);
71696     } catch (std::out_of_range& e) {
71697       {
71698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71699       };
71700     } catch (std::exception& e) {
71701       {
71702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71703       };
71704     } catch (...) {
71705       {
71706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71707       };
71708     }
71709   }
71710   jresult = new Dali::Actor((const Dali::Actor &)result);
71711   return jresult;
71712 }
71713
71714
71715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71716   void * jresult ;
71717   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71718   Dali::Toolkit::TableView::CellPosition arg2 ;
71719   Dali::Toolkit::TableView::CellPosition *argp2 ;
71720   Dali::Actor result;
71721
71722   arg1 = (Dali::Toolkit::TableView *)jarg1;
71723   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71724   if (!argp2) {
71725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71726     return 0;
71727   }
71728   arg2 = *argp2;
71729   {
71730     try {
71731       result = (arg1)->RemoveChildAt(arg2);
71732     } catch (std::out_of_range& e) {
71733       {
71734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71735       };
71736     } catch (std::exception& e) {
71737       {
71738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71739       };
71740     } catch (...) {
71741       {
71742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71743       };
71744     }
71745   }
71746   jresult = new Dali::Actor((const Dali::Actor &)result);
71747   return jresult;
71748 }
71749
71750
71751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71752   unsigned int jresult ;
71753   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71754   Dali::Actor arg2 ;
71755   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71756   Dali::Actor *argp2 ;
71757   bool result;
71758
71759   arg1 = (Dali::Toolkit::TableView *)jarg1;
71760   argp2 = (Dali::Actor *)jarg2;
71761   if (!argp2) {
71762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71763     return 0;
71764   }
71765   arg2 = *argp2;
71766   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71767   if (!arg3) {
71768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71769     return 0;
71770   }
71771   {
71772     try {
71773       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71774     } catch (std::out_of_range& e) {
71775       {
71776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71777       };
71778     } catch (std::exception& e) {
71779       {
71780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71781       };
71782     } catch (...) {
71783       {
71784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71785       };
71786     }
71787   }
71788   jresult = result;
71789   return jresult;
71790 }
71791
71792
71793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71794   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71795   unsigned int arg2 ;
71796
71797   arg1 = (Dali::Toolkit::TableView *)jarg1;
71798   arg2 = (unsigned int)jarg2;
71799   {
71800     try {
71801       (arg1)->InsertRow(arg2);
71802     } catch (std::out_of_range& e) {
71803       {
71804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71805       };
71806     } catch (std::exception& e) {
71807       {
71808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71809       };
71810     } catch (...) {
71811       {
71812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71813       };
71814     }
71815   }
71816 }
71817
71818
71819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71820   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71821   unsigned int arg2 ;
71822
71823   arg1 = (Dali::Toolkit::TableView *)jarg1;
71824   arg2 = (unsigned int)jarg2;
71825   {
71826     try {
71827       (arg1)->DeleteRow(arg2);
71828     } catch (std::out_of_range& e) {
71829       {
71830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71831       };
71832     } catch (std::exception& e) {
71833       {
71834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71835       };
71836     } catch (...) {
71837       {
71838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71839       };
71840     }
71841   }
71842 }
71843
71844
71845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71846   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71847   unsigned int arg2 ;
71848   std::vector< Dali::Actor > *arg3 = 0 ;
71849
71850   arg1 = (Dali::Toolkit::TableView *)jarg1;
71851   arg2 = (unsigned int)jarg2;
71852   arg3 = (std::vector< Dali::Actor > *)jarg3;
71853   if (!arg3) {
71854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71855     return ;
71856   }
71857   {
71858     try {
71859       (arg1)->DeleteRow(arg2,*arg3);
71860     } catch (std::out_of_range& e) {
71861       {
71862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71863       };
71864     } catch (std::exception& e) {
71865       {
71866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71867       };
71868     } catch (...) {
71869       {
71870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71871       };
71872     }
71873   }
71874 }
71875
71876
71877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71878   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71879   unsigned int arg2 ;
71880
71881   arg1 = (Dali::Toolkit::TableView *)jarg1;
71882   arg2 = (unsigned int)jarg2;
71883   {
71884     try {
71885       (arg1)->InsertColumn(arg2);
71886     } catch (std::out_of_range& e) {
71887       {
71888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71889       };
71890     } catch (std::exception& e) {
71891       {
71892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71893       };
71894     } catch (...) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71897       };
71898     }
71899   }
71900 }
71901
71902
71903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71905   unsigned int arg2 ;
71906
71907   arg1 = (Dali::Toolkit::TableView *)jarg1;
71908   arg2 = (unsigned int)jarg2;
71909   {
71910     try {
71911       (arg1)->DeleteColumn(arg2);
71912     } catch (std::out_of_range& e) {
71913       {
71914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71915       };
71916     } catch (std::exception& e) {
71917       {
71918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71919       };
71920     } catch (...) {
71921       {
71922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71923       };
71924     }
71925   }
71926 }
71927
71928
71929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71930   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71931   unsigned int arg2 ;
71932   std::vector< Dali::Actor > *arg3 = 0 ;
71933
71934   arg1 = (Dali::Toolkit::TableView *)jarg1;
71935   arg2 = (unsigned int)jarg2;
71936   arg3 = (std::vector< Dali::Actor > *)jarg3;
71937   if (!arg3) {
71938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71939     return ;
71940   }
71941   {
71942     try {
71943       (arg1)->DeleteColumn(arg2,*arg3);
71944     } catch (std::out_of_range& e) {
71945       {
71946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71947       };
71948     } catch (std::exception& e) {
71949       {
71950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71951       };
71952     } catch (...) {
71953       {
71954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71955       };
71956     }
71957   }
71958 }
71959
71960
71961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
71962   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71963   unsigned int arg2 ;
71964   unsigned int arg3 ;
71965
71966   arg1 = (Dali::Toolkit::TableView *)jarg1;
71967   arg2 = (unsigned int)jarg2;
71968   arg3 = (unsigned int)jarg3;
71969   {
71970     try {
71971       (arg1)->Resize(arg2,arg3);
71972     } catch (std::out_of_range& e) {
71973       {
71974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71975       };
71976     } catch (std::exception& e) {
71977       {
71978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71979       };
71980     } catch (...) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71983       };
71984     }
71985   }
71986 }
71987
71988
71989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
71990   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71991   unsigned int arg2 ;
71992   unsigned int arg3 ;
71993   std::vector< Dali::Actor > *arg4 = 0 ;
71994
71995   arg1 = (Dali::Toolkit::TableView *)jarg1;
71996   arg2 = (unsigned int)jarg2;
71997   arg3 = (unsigned int)jarg3;
71998   arg4 = (std::vector< Dali::Actor > *)jarg4;
71999   if (!arg4) {
72000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72001     return ;
72002   }
72003   {
72004     try {
72005       (arg1)->Resize(arg2,arg3,*arg4);
72006     } catch (std::out_of_range& e) {
72007       {
72008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72009       };
72010     } catch (std::exception& e) {
72011       {
72012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72013       };
72014     } catch (...) {
72015       {
72016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72017       };
72018     }
72019   }
72020 }
72021
72022
72023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72024   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72025   Dali::Size arg2 ;
72026   Dali::Size *argp2 ;
72027
72028   arg1 = (Dali::Toolkit::TableView *)jarg1;
72029   argp2 = (Dali::Size *)jarg2;
72030   if (!argp2) {
72031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72032     return ;
72033   }
72034   arg2 = *argp2;
72035   {
72036     try {
72037       (arg1)->SetCellPadding(arg2);
72038     } catch (std::out_of_range& e) {
72039       {
72040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72041       };
72042     } catch (std::exception& e) {
72043       {
72044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72045       };
72046     } catch (...) {
72047       {
72048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72049       };
72050     }
72051   }
72052 }
72053
72054
72055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72056   void * jresult ;
72057   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72058   Dali::Size result;
72059
72060   arg1 = (Dali::Toolkit::TableView *)jarg1;
72061   {
72062     try {
72063       result = (arg1)->GetCellPadding();
72064     } catch (std::out_of_range& e) {
72065       {
72066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72067       };
72068     } catch (std::exception& e) {
72069       {
72070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72071       };
72072     } catch (...) {
72073       {
72074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72075       };
72076     }
72077   }
72078   jresult = new Dali::Size((const Dali::Size &)result);
72079   return jresult;
72080 }
72081
72082
72083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72084   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72085   unsigned int arg2 ;
72086
72087   arg1 = (Dali::Toolkit::TableView *)jarg1;
72088   arg2 = (unsigned int)jarg2;
72089   {
72090     try {
72091       (arg1)->SetFitHeight(arg2);
72092     } catch (std::out_of_range& e) {
72093       {
72094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72095       };
72096     } catch (std::exception& e) {
72097       {
72098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72099       };
72100     } catch (...) {
72101       {
72102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72103       };
72104     }
72105   }
72106 }
72107
72108
72109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72110   unsigned int jresult ;
72111   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72112   unsigned int arg2 ;
72113   bool result;
72114
72115   arg1 = (Dali::Toolkit::TableView *)jarg1;
72116   arg2 = (unsigned int)jarg2;
72117   {
72118     try {
72119       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72120     } catch (std::out_of_range& e) {
72121       {
72122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72123       };
72124     } catch (std::exception& e) {
72125       {
72126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72127       };
72128     } catch (...) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72131       };
72132     }
72133   }
72134   jresult = result;
72135   return jresult;
72136 }
72137
72138
72139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72140   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72141   unsigned int arg2 ;
72142
72143   arg1 = (Dali::Toolkit::TableView *)jarg1;
72144   arg2 = (unsigned int)jarg2;
72145   {
72146     try {
72147       (arg1)->SetFitWidth(arg2);
72148     } catch (std::out_of_range& e) {
72149       {
72150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72151       };
72152     } catch (std::exception& e) {
72153       {
72154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72155       };
72156     } catch (...) {
72157       {
72158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72159       };
72160     }
72161   }
72162 }
72163
72164
72165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72166   unsigned int jresult ;
72167   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72168   unsigned int arg2 ;
72169   bool result;
72170
72171   arg1 = (Dali::Toolkit::TableView *)jarg1;
72172   arg2 = (unsigned int)jarg2;
72173   {
72174     try {
72175       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72176     } catch (std::out_of_range& e) {
72177       {
72178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72179       };
72180     } catch (std::exception& e) {
72181       {
72182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72183       };
72184     } catch (...) {
72185       {
72186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72187       };
72188     }
72189   }
72190   jresult = result;
72191   return jresult;
72192 }
72193
72194
72195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72196   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72197   unsigned int arg2 ;
72198   float arg3 ;
72199
72200   arg1 = (Dali::Toolkit::TableView *)jarg1;
72201   arg2 = (unsigned int)jarg2;
72202   arg3 = (float)jarg3;
72203   {
72204     try {
72205       (arg1)->SetFixedHeight(arg2,arg3);
72206     } catch (std::out_of_range& e) {
72207       {
72208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72209       };
72210     } catch (std::exception& e) {
72211       {
72212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72213       };
72214     } catch (...) {
72215       {
72216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72217       };
72218     }
72219   }
72220 }
72221
72222
72223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72224   float jresult ;
72225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72226   unsigned int arg2 ;
72227   float result;
72228
72229   arg1 = (Dali::Toolkit::TableView *)jarg1;
72230   arg2 = (unsigned int)jarg2;
72231   {
72232     try {
72233       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72234     } catch (std::out_of_range& e) {
72235       {
72236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72237       };
72238     } catch (std::exception& e) {
72239       {
72240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72241       };
72242     } catch (...) {
72243       {
72244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72245       };
72246     }
72247   }
72248   jresult = result;
72249   return jresult;
72250 }
72251
72252
72253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72254   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72255   unsigned int arg2 ;
72256   float arg3 ;
72257
72258   arg1 = (Dali::Toolkit::TableView *)jarg1;
72259   arg2 = (unsigned int)jarg2;
72260   arg3 = (float)jarg3;
72261   {
72262     try {
72263       (arg1)->SetRelativeHeight(arg2,arg3);
72264     } catch (std::out_of_range& e) {
72265       {
72266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72267       };
72268     } catch (std::exception& e) {
72269       {
72270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72271       };
72272     } catch (...) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72275       };
72276     }
72277   }
72278 }
72279
72280
72281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72282   float jresult ;
72283   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72284   unsigned int arg2 ;
72285   float result;
72286
72287   arg1 = (Dali::Toolkit::TableView *)jarg1;
72288   arg2 = (unsigned int)jarg2;
72289   {
72290     try {
72291       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72292     } catch (std::out_of_range& e) {
72293       {
72294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72295       };
72296     } catch (std::exception& e) {
72297       {
72298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72299       };
72300     } catch (...) {
72301       {
72302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72303       };
72304     }
72305   }
72306   jresult = result;
72307   return jresult;
72308 }
72309
72310
72311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72312   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72313   unsigned int arg2 ;
72314   float arg3 ;
72315
72316   arg1 = (Dali::Toolkit::TableView *)jarg1;
72317   arg2 = (unsigned int)jarg2;
72318   arg3 = (float)jarg3;
72319   {
72320     try {
72321       (arg1)->SetFixedWidth(arg2,arg3);
72322     } catch (std::out_of_range& e) {
72323       {
72324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72325       };
72326     } catch (std::exception& e) {
72327       {
72328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72329       };
72330     } catch (...) {
72331       {
72332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72333       };
72334     }
72335   }
72336 }
72337
72338
72339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72340   float jresult ;
72341   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72342   unsigned int arg2 ;
72343   float result;
72344
72345   arg1 = (Dali::Toolkit::TableView *)jarg1;
72346   arg2 = (unsigned int)jarg2;
72347   {
72348     try {
72349       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72350     } catch (std::out_of_range& e) {
72351       {
72352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (std::exception& e) {
72355       {
72356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (...) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72361       };
72362     }
72363   }
72364   jresult = result;
72365   return jresult;
72366 }
72367
72368
72369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72370   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72371   unsigned int arg2 ;
72372   float arg3 ;
72373
72374   arg1 = (Dali::Toolkit::TableView *)jarg1;
72375   arg2 = (unsigned int)jarg2;
72376   arg3 = (float)jarg3;
72377   {
72378     try {
72379       (arg1)->SetRelativeWidth(arg2,arg3);
72380     } catch (std::out_of_range& e) {
72381       {
72382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72383       };
72384     } catch (std::exception& e) {
72385       {
72386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72387       };
72388     } catch (...) {
72389       {
72390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72391       };
72392     }
72393   }
72394 }
72395
72396
72397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72398   float jresult ;
72399   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72400   unsigned int arg2 ;
72401   float result;
72402
72403   arg1 = (Dali::Toolkit::TableView *)jarg1;
72404   arg2 = (unsigned int)jarg2;
72405   {
72406     try {
72407       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72408     } catch (std::out_of_range& e) {
72409       {
72410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72411       };
72412     } catch (std::exception& e) {
72413       {
72414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72415       };
72416     } catch (...) {
72417       {
72418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72419       };
72420     }
72421   }
72422   jresult = result;
72423   return jresult;
72424 }
72425
72426
72427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72428   unsigned int jresult ;
72429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72430   unsigned int result;
72431
72432   arg1 = (Dali::Toolkit::TableView *)jarg1;
72433   {
72434     try {
72435       result = (unsigned int)(arg1)->GetRows();
72436     } catch (std::out_of_range& e) {
72437       {
72438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72439       };
72440     } catch (std::exception& e) {
72441       {
72442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72443       };
72444     } catch (...) {
72445       {
72446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72447       };
72448     }
72449   }
72450   jresult = result;
72451   return jresult;
72452 }
72453
72454
72455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72456   unsigned int jresult ;
72457   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72458   unsigned int result;
72459
72460   arg1 = (Dali::Toolkit::TableView *)jarg1;
72461   {
72462     try {
72463       result = (unsigned int)(arg1)->GetColumns();
72464     } catch (std::out_of_range& e) {
72465       {
72466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72467       };
72468     } catch (std::exception& e) {
72469       {
72470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72471       };
72472     } catch (...) {
72473       {
72474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72475       };
72476     }
72477   }
72478   jresult = result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72484   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72485   Dali::Toolkit::TableView::CellPosition arg2 ;
72486   Dali::HorizontalAlignment::Type arg3 ;
72487   Dali::VerticalAlignment::Type arg4 ;
72488   Dali::Toolkit::TableView::CellPosition *argp2 ;
72489
72490   arg1 = (Dali::Toolkit::TableView *)jarg1;
72491   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72492   if (!argp2) {
72493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72494     return ;
72495   }
72496   arg2 = *argp2;
72497   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72498   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72499   {
72500     try {
72501       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72502     } catch (std::out_of_range& e) {
72503       {
72504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72505       };
72506     } catch (std::exception& e) {
72507       {
72508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72509       };
72510     } catch (...) {
72511       {
72512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72513       };
72514     }
72515   }
72516 }
72517
72518
72519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72520   unsigned int jresult ;
72521   unsigned int result;
72522
72523   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72524   jresult = result;
72525   return jresult;
72526 }
72527
72528
72529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72530   int jresult ;
72531   int result;
72532
72533   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72534   jresult = (int)result;
72535   return jresult;
72536 }
72537
72538
72539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72540   int jresult ;
72541   int result;
72542
72543   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72544   jresult = (int)result;
72545   return jresult;
72546 }
72547
72548
72549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72550   int jresult ;
72551   int result;
72552
72553   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72554   jresult = (int)result;
72555   return jresult;
72556 }
72557
72558
72559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72560   int jresult ;
72561   int result;
72562
72563   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72564   jresult = (int)result;
72565   return jresult;
72566 }
72567
72568
72569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72570   int jresult ;
72571   int result;
72572
72573   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72574   jresult = (int)result;
72575   return jresult;
72576 }
72577
72578
72579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72580   int jresult ;
72581   int result;
72582
72583   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72584   jresult = (int)result;
72585   return jresult;
72586 }
72587
72588
72589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72590   int jresult ;
72591   int result;
72592
72593   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72594   jresult = (int)result;
72595   return jresult;
72596 }
72597
72598
72599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72600   int jresult ;
72601   int result;
72602
72603   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72604   jresult = (int)result;
72605   return jresult;
72606 }
72607
72608
72609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72610   int jresult ;
72611   int result;
72612
72613   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72614   jresult = (int)result;
72615   return jresult;
72616 }
72617
72618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
72619   int jresult ;
72620   int result;
72621
72622   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
72623   jresult = (int)result;
72624   return jresult;
72625 }
72626
72627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72628   int jresult ;
72629   int result;
72630
72631   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72632   jresult = (int)result;
72633   return jresult;
72634 }
72635
72636
72637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72638   int jresult ;
72639   int result;
72640
72641   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72642   jresult = (int)result;
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72648   int jresult ;
72649   int result;
72650
72651   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72652   jresult = (int)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72658   int jresult ;
72659   int result;
72660
72661   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72662   jresult = (int)result;
72663   return jresult;
72664 }
72665
72666
72667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72668   int jresult ;
72669   int result;
72670
72671   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72672   jresult = (int)result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72678   int jresult ;
72679   int result;
72680
72681   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72682   jresult = (int)result;
72683   return jresult;
72684 }
72685
72686
72687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72688   int jresult ;
72689   int result;
72690
72691   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72692   jresult = (int)result;
72693   return jresult;
72694 }
72695
72696
72697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72698   int jresult ;
72699   int result;
72700
72701   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72702   jresult = (int)result;
72703   return jresult;
72704 }
72705
72706
72707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72708   int jresult ;
72709   int result;
72710
72711   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72712   jresult = (int)result;
72713   return jresult;
72714 }
72715
72716
72717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72718   int jresult ;
72719   int result;
72720
72721   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72722   jresult = (int)result;
72723   return jresult;
72724 }
72725
72726
72727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72728   int jresult ;
72729   int result;
72730
72731   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72732   jresult = (int)result;
72733   return jresult;
72734 }
72735
72736
72737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72738   int jresult ;
72739   int result;
72740
72741   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72742   jresult = (int)result;
72743   return jresult;
72744 }
72745
72746
72747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72748   int jresult ;
72749   int result;
72750
72751   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72752   jresult = (int)result;
72753   return jresult;
72754 }
72755
72756
72757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72758   int jresult ;
72759   int result;
72760
72761   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72762   jresult = (int)result;
72763   return jresult;
72764 }
72765
72766
72767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72768   int jresult ;
72769   int result;
72770
72771   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72772   jresult = (int)result;
72773   return jresult;
72774 }
72775
72776
72777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72778   void * jresult ;
72779   Dali::Toolkit::TextLabel::Property *result = 0 ;
72780
72781   {
72782     try {
72783       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72784     } catch (std::out_of_range& e) {
72785       {
72786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72787       };
72788     } catch (std::exception& e) {
72789       {
72790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72791       };
72792     } catch (...) {
72793       {
72794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72795       };
72796     }
72797   }
72798   jresult = (void *)result;
72799   return jresult;
72800 }
72801
72802
72803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72804   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72805
72806   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72807   {
72808     try {
72809       delete arg1;
72810     } catch (std::out_of_range& e) {
72811       {
72812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72813       };
72814     } catch (std::exception& e) {
72815       {
72816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72817       };
72818     } catch (...) {
72819       {
72820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72821       };
72822     }
72823   }
72824 }
72825
72826
72827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72828   void * jresult ;
72829   Dali::Toolkit::TextLabel result;
72830
72831   {
72832     try {
72833       result = Dali::Toolkit::TextLabel::New();
72834     } catch (std::out_of_range& e) {
72835       {
72836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72837       };
72838     } catch (std::exception& e) {
72839       {
72840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72841       };
72842     } catch (...) {
72843       {
72844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72845       };
72846     }
72847   }
72848   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72849   return jresult;
72850 }
72851
72852
72853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72854   void * jresult ;
72855   std::string *arg1 = 0 ;
72856   Dali::Toolkit::TextLabel result;
72857
72858   if (!jarg1) {
72859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72860     return 0;
72861   }
72862   std::string arg1_str(jarg1);
72863   arg1 = &arg1_str;
72864   {
72865     try {
72866       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72867     } catch (std::out_of_range& e) {
72868       {
72869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72870       };
72871     } catch (std::exception& e) {
72872       {
72873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72874       };
72875     } catch (...) {
72876       {
72877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72878       };
72879     }
72880   }
72881   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72882
72883   //argout typemap for const std::string&
72884
72885   return jresult;
72886 }
72887
72888
72889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72890   void * jresult ;
72891   Dali::Toolkit::TextLabel *result = 0 ;
72892
72893   {
72894     try {
72895       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72896     } catch (std::out_of_range& e) {
72897       {
72898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72899       };
72900     } catch (std::exception& e) {
72901       {
72902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72903       };
72904     } catch (...) {
72905       {
72906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72907       };
72908     }
72909   }
72910   jresult = (void *)result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72916   void * jresult ;
72917   Dali::Toolkit::TextLabel *arg1 = 0 ;
72918   Dali::Toolkit::TextLabel *result = 0 ;
72919
72920   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72921   if (!arg1) {
72922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72923     return 0;
72924   }
72925   {
72926     try {
72927       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72928     } catch (std::out_of_range& e) {
72929       {
72930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72931       };
72932     } catch (std::exception& e) {
72933       {
72934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72935       };
72936     } catch (...) {
72937       {
72938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72939       };
72940     }
72941   }
72942   jresult = (void *)result;
72943   return jresult;
72944 }
72945
72946
72947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72948   void * jresult ;
72949   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72950   Dali::Toolkit::TextLabel *arg2 = 0 ;
72951   Dali::Toolkit::TextLabel *result = 0 ;
72952
72953   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72954   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72955   if (!arg2) {
72956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72957     return 0;
72958   }
72959   {
72960     try {
72961       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
72962     } catch (std::out_of_range& e) {
72963       {
72964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (std::exception& e) {
72967       {
72968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72969       };
72970     } catch (...) {
72971       {
72972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72973       };
72974     }
72975   }
72976   jresult = (void *)result;
72977   return jresult;
72978 }
72979
72980
72981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
72982   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72983
72984   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72985   {
72986     try {
72987       delete arg1;
72988     } catch (std::out_of_range& e) {
72989       {
72990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72991       };
72992     } catch (std::exception& e) {
72993       {
72994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (...) {
72997       {
72998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72999       };
73000     }
73001   }
73002 }
73003
73004
73005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73006   void * jresult ;
73007   Dali::BaseHandle arg1 ;
73008   Dali::BaseHandle *argp1 ;
73009   Dali::Toolkit::TextLabel result;
73010
73011   argp1 = (Dali::BaseHandle *)jarg1;
73012   if (!argp1) {
73013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73014     return 0;
73015   }
73016   arg1 = *argp1;
73017   {
73018     try {
73019       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73020     } catch (std::out_of_range& e) {
73021       {
73022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73023       };
73024     } catch (std::exception& e) {
73025       {
73026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73027       };
73028     } catch (...) {
73029       {
73030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73031       };
73032     }
73033   }
73034   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73035   return jresult;
73036 }
73037
73038
73039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73040   void * jresult ;
73041   Dali::Toolkit::AccessibilityManager *result = 0 ;
73042
73043   {
73044     try {
73045       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73046     } catch (std::out_of_range& e) {
73047       {
73048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73049       };
73050     } catch (std::exception& e) {
73051       {
73052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73053       };
73054     } catch (...) {
73055       {
73056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73057       };
73058     }
73059   }
73060   jresult = (void *)result;
73061   return jresult;
73062 }
73063
73064
73065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73066   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73067
73068   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73069   {
73070     try {
73071       delete arg1;
73072     } catch (std::out_of_range& e) {
73073       {
73074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73075       };
73076     } catch (std::exception& e) {
73077       {
73078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73079       };
73080     } catch (...) {
73081       {
73082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73083       };
73084     }
73085   }
73086 }
73087
73088
73089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73090   void * jresult ;
73091   Dali::Toolkit::AccessibilityManager result;
73092
73093   {
73094     try {
73095       result = Dali::Toolkit::AccessibilityManager::Get();
73096     } catch (std::out_of_range& e) {
73097       {
73098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73099       };
73100     } catch (std::exception& e) {
73101       {
73102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73107       };
73108     }
73109   }
73110   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73111   return jresult;
73112 }
73113
73114
73115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73117   Dali::Actor arg2 ;
73118   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73119   std::string *arg4 = 0 ;
73120   Dali::Actor *argp2 ;
73121
73122   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73123   argp2 = (Dali::Actor *)jarg2;
73124   if (!argp2) {
73125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73126     return ;
73127   }
73128   arg2 = *argp2;
73129   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73130   if (!jarg4) {
73131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73132     return ;
73133   }
73134   std::string arg4_str(jarg4);
73135   arg4 = &arg4_str;
73136   {
73137     try {
73138       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73139     } catch (std::out_of_range& e) {
73140       {
73141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73142       };
73143     } catch (std::exception& e) {
73144       {
73145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73146       };
73147     } catch (...) {
73148       {
73149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73150       };
73151     }
73152   }
73153
73154   //argout typemap for const std::string&
73155
73156 }
73157
73158
73159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73160   char * jresult ;
73161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73162   Dali::Actor arg2 ;
73163   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73164   Dali::Actor *argp2 ;
73165   std::string result;
73166
73167   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73168   argp2 = (Dali::Actor *)jarg2;
73169   if (!argp2) {
73170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73171     return 0;
73172   }
73173   arg2 = *argp2;
73174   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73175   {
73176     try {
73177       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73178     } catch (std::out_of_range& e) {
73179       {
73180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73181       };
73182     } catch (std::exception& e) {
73183       {
73184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (...) {
73187       {
73188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73189       };
73190     }
73191   }
73192   jresult = SWIG_csharp_string_callback((&result)->c_str());
73193   return jresult;
73194 }
73195
73196
73197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73198   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73199   Dali::Actor arg2 ;
73200   unsigned int arg3 ;
73201   Dali::Actor *argp2 ;
73202
73203   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73204   argp2 = (Dali::Actor *)jarg2;
73205   if (!argp2) {
73206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73207     return ;
73208   }
73209   arg2 = *argp2;
73210   arg3 = (unsigned int)jarg3;
73211   {
73212     try {
73213       (arg1)->SetFocusOrder(arg2,arg3);
73214     } catch (std::out_of_range& e) {
73215       {
73216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73217       };
73218     } catch (std::exception& e) {
73219       {
73220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73221       };
73222     } catch (...) {
73223       {
73224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73225       };
73226     }
73227   }
73228 }
73229
73230
73231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73232   unsigned int jresult ;
73233   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73234   Dali::Actor arg2 ;
73235   Dali::Actor *argp2 ;
73236   unsigned int result;
73237
73238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73239   argp2 = (Dali::Actor *)jarg2;
73240   if (!argp2) {
73241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73242     return 0;
73243   }
73244   arg2 = *argp2;
73245   {
73246     try {
73247       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (...) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73259       };
73260     }
73261   }
73262   jresult = result;
73263   return jresult;
73264 }
73265
73266
73267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73268   unsigned int jresult ;
73269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73270   unsigned int result;
73271
73272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73273   {
73274     try {
73275       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73276     } catch (std::out_of_range& e) {
73277       {
73278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73279       };
73280     } catch (std::exception& e) {
73281       {
73282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73283       };
73284     } catch (...) {
73285       {
73286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73287       };
73288     }
73289   }
73290   jresult = result;
73291   return jresult;
73292 }
73293
73294
73295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73296   void * jresult ;
73297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73298   unsigned int arg2 ;
73299   Dali::Actor result;
73300
73301   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73302   arg2 = (unsigned int)jarg2;
73303   {
73304     try {
73305       result = (arg1)->GetActorByFocusOrder(arg2);
73306     } catch (std::out_of_range& e) {
73307       {
73308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73309       };
73310     } catch (std::exception& e) {
73311       {
73312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (...) {
73315       {
73316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73317       };
73318     }
73319   }
73320   jresult = new Dali::Actor((const Dali::Actor &)result);
73321   return jresult;
73322 }
73323
73324
73325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73326   unsigned int jresult ;
73327   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73328   Dali::Actor arg2 ;
73329   Dali::Actor *argp2 ;
73330   bool result;
73331
73332   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73333   argp2 = (Dali::Actor *)jarg2;
73334   if (!argp2) {
73335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73336     return 0;
73337   }
73338   arg2 = *argp2;
73339   {
73340     try {
73341       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73342     } catch (std::out_of_range& e) {
73343       {
73344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73345       };
73346     } catch (std::exception& e) {
73347       {
73348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73349       };
73350     } catch (...) {
73351       {
73352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73353       };
73354     }
73355   }
73356   jresult = result;
73357   return jresult;
73358 }
73359
73360
73361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73362   void * jresult ;
73363   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73364   Dali::Actor result;
73365
73366   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73367   {
73368     try {
73369       result = (arg1)->GetCurrentFocusActor();
73370     } catch (std::out_of_range& e) {
73371       {
73372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73373       };
73374     } catch (std::exception& e) {
73375       {
73376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73377       };
73378     } catch (...) {
73379       {
73380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73381       };
73382     }
73383   }
73384   jresult = new Dali::Actor((const Dali::Actor &)result);
73385   return jresult;
73386 }
73387
73388
73389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73390   void * jresult ;
73391   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73392   Dali::Actor result;
73393
73394   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73395   {
73396     try {
73397       result = (arg1)->GetCurrentFocusGroup();
73398     } catch (std::out_of_range& e) {
73399       {
73400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (std::exception& e) {
73403       {
73404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73405       };
73406     } catch (...) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73409       };
73410     }
73411   }
73412   jresult = new Dali::Actor((const Dali::Actor &)result);
73413   return jresult;
73414 }
73415
73416
73417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73418   unsigned int jresult ;
73419   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73420   unsigned int result;
73421
73422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73423   {
73424     try {
73425       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440   jresult = result;
73441   return jresult;
73442 }
73443
73444
73445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73446   unsigned int jresult ;
73447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73448   bool result;
73449
73450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73451   {
73452     try {
73453       result = (bool)(arg1)->MoveFocusForward();
73454     } catch (std::out_of_range& e) {
73455       {
73456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73457       };
73458     } catch (std::exception& e) {
73459       {
73460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73461       };
73462     } catch (...) {
73463       {
73464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73465       };
73466     }
73467   }
73468   jresult = result;
73469   return jresult;
73470 }
73471
73472
73473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73474   unsigned int jresult ;
73475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73476   bool result;
73477
73478   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73479   {
73480     try {
73481       result = (bool)(arg1)->MoveFocusBackward();
73482     } catch (std::out_of_range& e) {
73483       {
73484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73485       };
73486     } catch (std::exception& e) {
73487       {
73488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73489       };
73490     } catch (...) {
73491       {
73492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73493       };
73494     }
73495   }
73496   jresult = result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73503
73504   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73505   {
73506     try {
73507       (arg1)->ClearFocus();
73508     } catch (std::out_of_range& e) {
73509       {
73510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73511       };
73512     } catch (std::exception& e) {
73513       {
73514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73515       };
73516     } catch (...) {
73517       {
73518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73519       };
73520     }
73521   }
73522 }
73523
73524
73525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73527
73528   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73529   {
73530     try {
73531       (arg1)->Reset();
73532     } catch (std::out_of_range& e) {
73533       {
73534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73535       };
73536     } catch (std::exception& e) {
73537       {
73538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73539       };
73540     } catch (...) {
73541       {
73542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73543       };
73544     }
73545   }
73546 }
73547
73548
73549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73551   Dali::Actor arg2 ;
73552   bool arg3 ;
73553   Dali::Actor *argp2 ;
73554
73555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73556   argp2 = (Dali::Actor *)jarg2;
73557   if (!argp2) {
73558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73559     return ;
73560   }
73561   arg2 = *argp2;
73562   arg3 = jarg3 ? true : false;
73563   {
73564     try {
73565       (arg1)->SetFocusGroup(arg2,arg3);
73566     } catch (std::out_of_range& e) {
73567       {
73568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73569       };
73570     } catch (std::exception& e) {
73571       {
73572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73573       };
73574     } catch (...) {
73575       {
73576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73577       };
73578     }
73579   }
73580 }
73581
73582
73583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73584   unsigned int jresult ;
73585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73586   Dali::Actor arg2 ;
73587   Dali::Actor *argp2 ;
73588   bool result;
73589
73590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73591   argp2 = (Dali::Actor *)jarg2;
73592   if (!argp2) {
73593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73594     return 0;
73595   }
73596   arg2 = *argp2;
73597   {
73598     try {
73599       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (...) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73611       };
73612     }
73613   }
73614   jresult = result;
73615   return jresult;
73616 }
73617
73618
73619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73621   bool arg2 ;
73622
73623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73624   arg2 = jarg2 ? true : false;
73625   {
73626     try {
73627       (arg1)->SetGroupMode(arg2);
73628     } catch (std::out_of_range& e) {
73629       {
73630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73631       };
73632     } catch (std::exception& e) {
73633       {
73634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73635       };
73636     } catch (...) {
73637       {
73638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73639       };
73640     }
73641   }
73642 }
73643
73644
73645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73646   unsigned int jresult ;
73647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73648   bool result;
73649
73650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73651   {
73652     try {
73653       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73654     } catch (std::out_of_range& e) {
73655       {
73656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73657       };
73658     } catch (std::exception& e) {
73659       {
73660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73661       };
73662     } catch (...) {
73663       {
73664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73665       };
73666     }
73667   }
73668   jresult = result;
73669   return jresult;
73670 }
73671
73672
73673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73675   bool arg2 ;
73676
73677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73678   arg2 = jarg2 ? true : false;
73679   {
73680     try {
73681       (arg1)->SetWrapMode(arg2);
73682     } catch (std::out_of_range& e) {
73683       {
73684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73685       };
73686     } catch (std::exception& e) {
73687       {
73688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73689       };
73690     } catch (...) {
73691       {
73692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73693       };
73694     }
73695   }
73696 }
73697
73698
73699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73700   unsigned int jresult ;
73701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73702   bool result;
73703
73704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73705   {
73706     try {
73707       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73708     } catch (std::out_of_range& e) {
73709       {
73710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73711       };
73712     } catch (std::exception& e) {
73713       {
73714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (...) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73719       };
73720     }
73721   }
73722   jresult = result;
73723   return jresult;
73724 }
73725
73726
73727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73729   Dali::Actor arg2 ;
73730   Dali::Actor *argp2 ;
73731
73732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73733   argp2 = (Dali::Actor *)jarg2;
73734   if (!argp2) {
73735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73736     return ;
73737   }
73738   arg2 = *argp2;
73739   {
73740     try {
73741       (arg1)->SetFocusIndicatorActor(arg2);
73742     } catch (std::out_of_range& e) {
73743       {
73744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73745       };
73746     } catch (std::exception& e) {
73747       {
73748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73749       };
73750     } catch (...) {
73751       {
73752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73753       };
73754     }
73755   }
73756 }
73757
73758
73759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73760   void * jresult ;
73761   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73762   Dali::Actor result;
73763
73764   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73765   {
73766     try {
73767       result = (arg1)->GetFocusIndicatorActor();
73768     } catch (std::out_of_range& e) {
73769       {
73770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73771       };
73772     } catch (std::exception& e) {
73773       {
73774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73775       };
73776     } catch (...) {
73777       {
73778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73779       };
73780     }
73781   }
73782   jresult = new Dali::Actor((const Dali::Actor &)result);
73783   return jresult;
73784 }
73785
73786
73787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73788   void * jresult ;
73789   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73790   Dali::Actor arg2 ;
73791   Dali::Actor *argp2 ;
73792   Dali::Actor result;
73793
73794   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73795   argp2 = (Dali::Actor *)jarg2;
73796   if (!argp2) {
73797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73798     return 0;
73799   }
73800   arg2 = *argp2;
73801   {
73802     try {
73803       result = (arg1)->GetFocusGroup(arg2);
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73811       };
73812     } catch (...) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73815       };
73816     }
73817   }
73818   jresult = new Dali::Actor((const Dali::Actor &)result);
73819   return jresult;
73820 }
73821
73822
73823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73824   void * jresult ;
73825   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73826   Dali::Vector2 result;
73827
73828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73829   {
73830     try {
73831       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73832     } catch (std::out_of_range& e) {
73833       {
73834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73835       };
73836     } catch (std::exception& e) {
73837       {
73838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73839       };
73840     } catch (...) {
73841       {
73842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73843       };
73844     }
73845   }
73846   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73847   return jresult;
73848 }
73849
73850
73851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73852   void * jresult ;
73853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73854   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73855
73856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73857   {
73858     try {
73859       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73860     } catch (std::out_of_range& e) {
73861       {
73862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (std::exception& e) {
73865       {
73866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73867       };
73868     } catch (...) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73871       };
73872     }
73873   }
73874   jresult = (void *)result;
73875   return jresult;
73876 }
73877
73878
73879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73880   void * jresult ;
73881   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73882   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73883
73884   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73885   {
73886     try {
73887       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73888     } catch (std::out_of_range& e) {
73889       {
73890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (std::exception& e) {
73893       {
73894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73899       };
73900     }
73901   }
73902   jresult = (void *)result;
73903   return jresult;
73904 }
73905
73906
73907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73908   void * jresult ;
73909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73910   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73911
73912   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73913   {
73914     try {
73915       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73916     } catch (std::out_of_range& e) {
73917       {
73918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73919       };
73920     } catch (std::exception& e) {
73921       {
73922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73923       };
73924     } catch (...) {
73925       {
73926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73927       };
73928     }
73929   }
73930   jresult = (void *)result;
73931   return jresult;
73932 }
73933
73934
73935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73936   void * jresult ;
73937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73938   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73939
73940   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73941   {
73942     try {
73943       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73944     } catch (std::out_of_range& e) {
73945       {
73946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73947       };
73948     } catch (std::exception& e) {
73949       {
73950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73951       };
73952     } catch (...) {
73953       {
73954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73955       };
73956     }
73957   }
73958   jresult = (void *)result;
73959   return jresult;
73960 }
73961
73962
73963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
73964   void * jresult ;
73965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73966   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73967
73968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73969   {
73970     try {
73971       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
73972     } catch (std::out_of_range& e) {
73973       {
73974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73975       };
73976     } catch (std::exception& e) {
73977       {
73978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73979       };
73980     } catch (...) {
73981       {
73982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73983       };
73984     }
73985   }
73986   jresult = (void *)result;
73987   return jresult;
73988 }
73989
73990
73991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
73992   void * jresult ;
73993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73994   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73995
73996   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73997   {
73998     try {
73999       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74000     } catch (std::out_of_range& e) {
74001       {
74002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74003       };
74004     } catch (std::exception& e) {
74005       {
74006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74007       };
74008     } catch (...) {
74009       {
74010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74011       };
74012     }
74013   }
74014   jresult = (void *)result;
74015   return jresult;
74016 }
74017
74018
74019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74020   void * jresult ;
74021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74022   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74023
74024   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74025   {
74026     try {
74027       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
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 = (void *)result;
74043   return jresult;
74044 }
74045
74046
74047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74048   void * jresult ;
74049   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74050   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74051
74052   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74053   {
74054     try {
74055       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74056     } catch (std::out_of_range& e) {
74057       {
74058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74059       };
74060     } catch (std::exception& e) {
74061       {
74062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74063       };
74064     } catch (...) {
74065       {
74066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74067       };
74068     }
74069   }
74070   jresult = (void *)result;
74071   return jresult;
74072 }
74073
74074
74075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74076   void * jresult ;
74077   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74078   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74079
74080   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74081   {
74082     try {
74083       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74084     } catch (std::out_of_range& e) {
74085       {
74086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74087       };
74088     } catch (std::exception& e) {
74089       {
74090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74091       };
74092     } catch (...) {
74093       {
74094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74095       };
74096     }
74097   }
74098   jresult = (void *)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74104   void * jresult ;
74105   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74106   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74107
74108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74109   {
74110     try {
74111       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74112     } catch (std::out_of_range& e) {
74113       {
74114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74115       };
74116     } catch (std::exception& e) {
74117       {
74118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74119       };
74120     } catch (...) {
74121       {
74122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74123       };
74124     }
74125   }
74126   jresult = (void *)result;
74127   return jresult;
74128 }
74129
74130
74131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74132   void * jresult ;
74133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74134   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74135
74136   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74137   {
74138     try {
74139       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74147       };
74148     } catch (...) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74151       };
74152     }
74153   }
74154   jresult = (void *)result;
74155   return jresult;
74156 }
74157
74158
74159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74160   void * jresult ;
74161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74162   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74163
74164   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74165   {
74166     try {
74167       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74168     } catch (std::out_of_range& e) {
74169       {
74170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74171       };
74172     } catch (std::exception& e) {
74173       {
74174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74175       };
74176     } catch (...) {
74177       {
74178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74179       };
74180     }
74181   }
74182   jresult = (void *)result;
74183   return jresult;
74184 }
74185
74186
74187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74188   void * jresult ;
74189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74190   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74191
74192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74193   {
74194     try {
74195       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74196     } catch (std::out_of_range& e) {
74197       {
74198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74199       };
74200     } catch (std::exception& e) {
74201       {
74202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74203       };
74204     } catch (...) {
74205       {
74206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74207       };
74208     }
74209   }
74210   jresult = (void *)result;
74211   return jresult;
74212 }
74213
74214
74215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74216   void * jresult ;
74217   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74218   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74219
74220   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74221   {
74222     try {
74223       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74224     } catch (std::out_of_range& e) {
74225       {
74226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74227       };
74228     } catch (std::exception& e) {
74229       {
74230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74231       };
74232     } catch (...) {
74233       {
74234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74235       };
74236     }
74237   }
74238   jresult = (void *)result;
74239   return jresult;
74240 }
74241
74242
74243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74244   void * jresult ;
74245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74246   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74247
74248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74249   {
74250     try {
74251       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74252     } catch (std::out_of_range& e) {
74253       {
74254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74255       };
74256     } catch (std::exception& e) {
74257       {
74258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74259       };
74260     } catch (...) {
74261       {
74262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74263       };
74264     }
74265   }
74266   jresult = (void *)result;
74267   return jresult;
74268 }
74269
74270
74271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74272   void * jresult ;
74273   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74274   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74275
74276   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74277   {
74278     try {
74279       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74280     } catch (std::out_of_range& e) {
74281       {
74282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (std::exception& e) {
74285       {
74286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74287       };
74288     } catch (...) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74291       };
74292     }
74293   }
74294   jresult = (void *)result;
74295   return jresult;
74296 }
74297
74298
74299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74300   void * jresult ;
74301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74302   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74303
74304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74305   {
74306     try {
74307       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74308     } catch (std::out_of_range& e) {
74309       {
74310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74311       };
74312     } catch (std::exception& e) {
74313       {
74314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74315       };
74316     } catch (...) {
74317       {
74318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74319       };
74320     }
74321   }
74322   jresult = (void *)result;
74323   return jresult;
74324 }
74325
74326
74327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74328   void * jresult ;
74329   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74330   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74331
74332   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74333   {
74334     try {
74335       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74336     } catch (std::out_of_range& e) {
74337       {
74338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74339       };
74340     } catch (std::exception& e) {
74341       {
74342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74343       };
74344     } catch (...) {
74345       {
74346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74347       };
74348     }
74349   }
74350   jresult = (void *)result;
74351   return jresult;
74352 }
74353
74354
74355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74356   void * jresult ;
74357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74358   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74359
74360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74361   {
74362     try {
74363       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74364     } catch (std::out_of_range& e) {
74365       {
74366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74367       };
74368     } catch (std::exception& e) {
74369       {
74370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74371       };
74372     } catch (...) {
74373       {
74374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74375       };
74376     }
74377   }
74378   jresult = (void *)result;
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74384   void * jresult ;
74385   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74386   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74387
74388   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74389   {
74390     try {
74391       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74392     } catch (std::out_of_range& e) {
74393       {
74394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74395       };
74396     } catch (std::exception& e) {
74397       {
74398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74399       };
74400     } catch (...) {
74401       {
74402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74403       };
74404     }
74405   }
74406   jresult = (void *)result;
74407   return jresult;
74408 }
74409
74410
74411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74412   void * jresult ;
74413   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74414   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74415
74416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74417   {
74418     try {
74419       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74420     } catch (std::out_of_range& e) {
74421       {
74422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74423       };
74424     } catch (std::exception& e) {
74425       {
74426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74427       };
74428     } catch (...) {
74429       {
74430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74431       };
74432     }
74433   }
74434   jresult = (void *)result;
74435   return jresult;
74436 }
74437
74438
74439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74440   void * jresult ;
74441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74442   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74443
74444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74445   {
74446     try {
74447       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74448     } catch (std::out_of_range& e) {
74449       {
74450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74451       };
74452     } catch (std::exception& e) {
74453       {
74454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74455       };
74456     } catch (...) {
74457       {
74458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74459       };
74460     }
74461   }
74462   jresult = (void *)result;
74463   return jresult;
74464 }
74465
74466
74467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74468   void * jresult ;
74469   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74470   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74471
74472   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74473   {
74474     try {
74475       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74476     } catch (std::out_of_range& e) {
74477       {
74478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74479       };
74480     } catch (std::exception& e) {
74481       {
74482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74483       };
74484     } catch (...) {
74485       {
74486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74487       };
74488     }
74489   }
74490   jresult = (void *)result;
74491   return jresult;
74492 }
74493
74494
74495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74496   void * jresult ;
74497   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74498   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74499
74500   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74501   {
74502     try {
74503       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74504     } catch (std::out_of_range& e) {
74505       {
74506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74507       };
74508     } catch (std::exception& e) {
74509       {
74510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74511       };
74512     } catch (...) {
74513       {
74514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74515       };
74516     }
74517   }
74518   jresult = (void *)result;
74519   return jresult;
74520 }
74521
74522
74523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74524   void * jresult ;
74525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74526   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74527
74528   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74529   {
74530     try {
74531       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74532     } catch (std::out_of_range& e) {
74533       {
74534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74535       };
74536     } catch (std::exception& e) {
74537       {
74538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74539       };
74540     } catch (...) {
74541       {
74542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74543       };
74544     }
74545   }
74546   jresult = (void *)result;
74547   return jresult;
74548 }
74549
74550
74551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74552   void * jresult ;
74553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74554   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74555
74556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74557   {
74558     try {
74559       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74560     } catch (std::out_of_range& e) {
74561       {
74562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (std::exception& e) {
74565       {
74566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74571       };
74572     }
74573   }
74574   jresult = (void *)result;
74575   return jresult;
74576 }
74577
74578
74579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74580   void * jresult ;
74581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74582   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74583
74584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74585   {
74586     try {
74587       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74588     } catch (std::out_of_range& e) {
74589       {
74590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74591       };
74592     } catch (std::exception& e) {
74593       {
74594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74595       };
74596     } catch (...) {
74597       {
74598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74599       };
74600     }
74601   }
74602   jresult = (void *)result;
74603   return jresult;
74604 }
74605
74606
74607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74608   void * jresult ;
74609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74610   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74611
74612   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74613   {
74614     try {
74615       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74616     } catch (std::out_of_range& e) {
74617       {
74618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74619       };
74620     } catch (std::exception& e) {
74621       {
74622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74623       };
74624     } catch (...) {
74625       {
74626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74627       };
74628     }
74629   }
74630   jresult = (void *)result;
74631   return jresult;
74632 }
74633
74634
74635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74636   void * jresult ;
74637   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74638   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74639
74640   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74641   {
74642     try {
74643       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74644     } catch (std::out_of_range& e) {
74645       {
74646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74647       };
74648     } catch (std::exception& e) {
74649       {
74650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74651       };
74652     } catch (...) {
74653       {
74654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74655       };
74656     }
74657   }
74658   jresult = (void *)result;
74659   return jresult;
74660 }
74661
74662
74663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74664   void * jresult ;
74665   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74666   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74667
74668   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74669   {
74670     try {
74671       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74672     } catch (std::out_of_range& e) {
74673       {
74674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74675       };
74676     } catch (std::exception& e) {
74677       {
74678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74679       };
74680     } catch (...) {
74681       {
74682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74683       };
74684     }
74685   }
74686   jresult = (void *)result;
74687   return jresult;
74688 }
74689
74690
74691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74692   void * jresult ;
74693   Dali::Toolkit::StyleManager *result = 0 ;
74694
74695   {
74696     try {
74697       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74698     } catch (std::out_of_range& e) {
74699       {
74700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74701       };
74702     } catch (std::exception& e) {
74703       {
74704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74705       };
74706     } catch (...) {
74707       {
74708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74709       };
74710     }
74711   }
74712   jresult = (void *)result;
74713   return jresult;
74714 }
74715
74716
74717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74718   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74719
74720   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74721   {
74722     try {
74723       delete arg1;
74724     } catch (std::out_of_range& e) {
74725       {
74726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74727       };
74728     } catch (std::exception& e) {
74729       {
74730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74731       };
74732     } catch (...) {
74733       {
74734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74735       };
74736     }
74737   }
74738 }
74739
74740
74741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74742   void * jresult ;
74743   Dali::Toolkit::StyleManager result;
74744
74745   {
74746     try {
74747       result = Dali::Toolkit::StyleManager::Get();
74748     } catch (std::out_of_range& e) {
74749       {
74750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74751       };
74752     } catch (std::exception& e) {
74753       {
74754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74755       };
74756     } catch (...) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74759       };
74760     }
74761   }
74762   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74763   return jresult;
74764 }
74765
74766
74767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74768   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74769   std::string *arg2 = 0 ;
74770
74771   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74772   if (!jarg2) {
74773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74774     return ;
74775   }
74776   std::string arg2_str(jarg2);
74777   arg2 = &arg2_str;
74778   {
74779     try {
74780       (arg1)->ApplyTheme((std::string const &)*arg2);
74781     } catch (std::out_of_range& e) {
74782       {
74783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74784       };
74785     } catch (std::exception& e) {
74786       {
74787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74792       };
74793     }
74794   }
74795
74796   //argout typemap for const std::string&
74797
74798 }
74799
74800
74801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74802   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74803
74804   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74805   {
74806     try {
74807       (arg1)->ApplyDefaultTheme();
74808     } catch (std::out_of_range& e) {
74809       {
74810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74811       };
74812     } catch (std::exception& e) {
74813       {
74814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74815       };
74816     } catch (...) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74819       };
74820     }
74821   }
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74826   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74827   std::string *arg2 = 0 ;
74828   Dali::Property::Value *arg3 = 0 ;
74829
74830   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74831   if (!jarg2) {
74832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74833     return ;
74834   }
74835   std::string arg2_str(jarg2);
74836   arg2 = &arg2_str;
74837   arg3 = (Dali::Property::Value *)jarg3;
74838   if (!arg3) {
74839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74840     return ;
74841   }
74842   {
74843     try {
74844       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74845     } catch (std::out_of_range& e) {
74846       {
74847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74848       };
74849     } catch (std::exception& e) {
74850       {
74851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74852       };
74853     } catch (...) {
74854       {
74855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74856       };
74857     }
74858   }
74859
74860   //argout typemap for const std::string&
74861
74862 }
74863
74864
74865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74866   unsigned int jresult ;
74867   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74868   std::string *arg2 = 0 ;
74869   Dali::Property::Value *arg3 = 0 ;
74870   bool result;
74871
74872   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74873   if (!jarg2) {
74874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74875     return 0;
74876   }
74877   std::string arg2_str(jarg2);
74878   arg2 = &arg2_str;
74879   arg3 = (Dali::Property::Value *)jarg3;
74880   if (!arg3) {
74881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74882     return 0;
74883   }
74884   {
74885     try {
74886       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74887     } catch (std::out_of_range& e) {
74888       {
74889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74890       };
74891     } catch (std::exception& e) {
74892       {
74893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74894       };
74895     } catch (...) {
74896       {
74897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74898       };
74899     }
74900   }
74901   jresult = result;
74902
74903   //argout typemap for const std::string&
74904
74905   return jresult;
74906 }
74907
74908
74909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74910   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74911   Dali::Toolkit::Control arg2 ;
74912   std::string *arg3 = 0 ;
74913   std::string *arg4 = 0 ;
74914   Dali::Toolkit::Control *argp2 ;
74915
74916   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74917   argp2 = (Dali::Toolkit::Control *)jarg2;
74918   if (!argp2) {
74919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74920     return ;
74921   }
74922   arg2 = *argp2;
74923   if (!jarg3) {
74924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74925     return ;
74926   }
74927   std::string arg3_str(jarg3);
74928   arg3 = &arg3_str;
74929   if (!jarg4) {
74930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74931     return ;
74932   }
74933   std::string arg4_str(jarg4);
74934   arg4 = &arg4_str;
74935   {
74936     try {
74937       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74938     } catch (std::out_of_range& e) {
74939       {
74940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74941       };
74942     } catch (std::exception& e) {
74943       {
74944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74945       };
74946     } catch (...) {
74947       {
74948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74949       };
74950     }
74951   }
74952
74953   //argout typemap for const std::string&
74954
74955
74956   //argout typemap for const std::string&
74957
74958 }
74959
74960
74961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
74962   void * jresult ;
74963   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74964   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
74965
74966   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74967   {
74968     try {
74969       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
74970     } catch (std::out_of_range& e) {
74971       {
74972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74973       };
74974     } catch (std::exception& e) {
74975       {
74976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74977       };
74978     } catch (...) {
74979       {
74980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74981       };
74982     }
74983   }
74984   jresult = (void *)result;
74985   return jresult;
74986 }
74987
74988
74989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
74990   int jresult ;
74991   int result;
74992
74993   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
74994   jresult = (int)result;
74995   return jresult;
74996 }
74997
74998
74999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75000   int jresult ;
75001   int result;
75002
75003   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75004   jresult = (int)result;
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75010   int jresult ;
75011   int result;
75012
75013   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75014   jresult = (int)result;
75015   return jresult;
75016 }
75017
75018
75019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75020   int jresult ;
75021   int result;
75022
75023   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75024   jresult = (int)result;
75025   return jresult;
75026 }
75027
75028
75029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75030   int jresult ;
75031   int result;
75032
75033   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75034   jresult = (int)result;
75035   return jresult;
75036 }
75037
75038
75039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75040   int jresult ;
75041   int result;
75042
75043   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75044   jresult = (int)result;
75045   return jresult;
75046 }
75047
75048
75049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75050   int jresult ;
75051   int result;
75052
75053   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75054   jresult = (int)result;
75055   return jresult;
75056 }
75057
75058
75059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75060   int jresult ;
75061   int result;
75062
75063   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75064   jresult = (int)result;
75065   return jresult;
75066 }
75067
75068
75069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75070   int jresult ;
75071   int result;
75072
75073   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75074   jresult = (int)result;
75075   return jresult;
75076 }
75077
75078
75079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75080   int jresult ;
75081   int result;
75082
75083   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75084   jresult = (int)result;
75085   return jresult;
75086 }
75087
75088
75089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75090   int jresult ;
75091   int result;
75092
75093   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75094   jresult = (int)result;
75095   return jresult;
75096 }
75097
75098
75099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75100   int jresult ;
75101   int result;
75102
75103   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75104   jresult = (int)result;
75105   return jresult;
75106 }
75107
75108
75109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75110   int jresult ;
75111   int result;
75112
75113   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75114   jresult = (int)result;
75115   return jresult;
75116 }
75117
75118
75119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75120   int jresult ;
75121   int result;
75122
75123   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75124   jresult = (int)result;
75125   return jresult;
75126 }
75127
75128
75129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75130   int jresult ;
75131   int result;
75132
75133   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75134   jresult = (int)result;
75135   return jresult;
75136 }
75137
75138
75139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75140   void * jresult ;
75141   Dali::Toolkit::Slider::Property *result = 0 ;
75142
75143   {
75144     try {
75145       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75146     } catch (std::out_of_range& e) {
75147       {
75148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75149       };
75150     } catch (std::exception& e) {
75151       {
75152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75153       };
75154     } catch (...) {
75155       {
75156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75157       };
75158     }
75159   }
75160   jresult = (void *)result;
75161   return jresult;
75162 }
75163
75164
75165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75166   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75167
75168   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75169   {
75170     try {
75171       delete arg1;
75172     } catch (std::out_of_range& e) {
75173       {
75174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75175       };
75176     } catch (std::exception& e) {
75177       {
75178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75179       };
75180     } catch (...) {
75181       {
75182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75183       };
75184     }
75185   }
75186 }
75187
75188
75189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75190   void * jresult ;
75191   Dali::Toolkit::Slider result;
75192
75193   {
75194     try {
75195       result = Dali::Toolkit::Slider::New();
75196     } catch (std::out_of_range& e) {
75197       {
75198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75199       };
75200     } catch (std::exception& e) {
75201       {
75202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75203       };
75204     } catch (...) {
75205       {
75206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75207       };
75208     }
75209   }
75210   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75211   return jresult;
75212 }
75213
75214
75215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75216   void * jresult ;
75217   Dali::Toolkit::Slider *result = 0 ;
75218
75219   {
75220     try {
75221       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75222     } catch (std::out_of_range& e) {
75223       {
75224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75225       };
75226     } catch (std::exception& e) {
75227       {
75228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75229       };
75230     } catch (...) {
75231       {
75232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75233       };
75234     }
75235   }
75236   jresult = (void *)result;
75237   return jresult;
75238 }
75239
75240
75241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75242   void * jresult ;
75243   Dali::Toolkit::Slider *arg1 = 0 ;
75244   Dali::Toolkit::Slider *result = 0 ;
75245
75246   arg1 = (Dali::Toolkit::Slider *)jarg1;
75247   if (!arg1) {
75248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75249     return 0;
75250   }
75251   {
75252     try {
75253       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75254     } catch (std::out_of_range& e) {
75255       {
75256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75257       };
75258     } catch (std::exception& e) {
75259       {
75260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75261       };
75262     } catch (...) {
75263       {
75264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75265       };
75266     }
75267   }
75268   jresult = (void *)result;
75269   return jresult;
75270 }
75271
75272
75273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75274   void * jresult ;
75275   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75276   Dali::Toolkit::Slider *arg2 = 0 ;
75277   Dali::Toolkit::Slider *result = 0 ;
75278
75279   arg1 = (Dali::Toolkit::Slider *)jarg1;
75280   arg2 = (Dali::Toolkit::Slider *)jarg2;
75281   if (!arg2) {
75282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75283     return 0;
75284   }
75285   {
75286     try {
75287       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75288     } catch (std::out_of_range& e) {
75289       {
75290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75291       };
75292     } catch (std::exception& e) {
75293       {
75294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75295       };
75296     } catch (...) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75299       };
75300     }
75301   }
75302   jresult = (void *)result;
75303   return jresult;
75304 }
75305
75306
75307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75308   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75309
75310   arg1 = (Dali::Toolkit::Slider *)jarg1;
75311   {
75312     try {
75313       delete arg1;
75314     } catch (std::out_of_range& e) {
75315       {
75316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75317       };
75318     } catch (std::exception& e) {
75319       {
75320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75321       };
75322     } catch (...) {
75323       {
75324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75325       };
75326     }
75327   }
75328 }
75329
75330
75331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75332   void * jresult ;
75333   Dali::BaseHandle arg1 ;
75334   Dali::BaseHandle *argp1 ;
75335   Dali::Toolkit::Slider result;
75336
75337   argp1 = (Dali::BaseHandle *)jarg1;
75338   if (!argp1) {
75339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75340     return 0;
75341   }
75342   arg1 = *argp1;
75343   {
75344     try {
75345       result = Dali::Toolkit::Slider::DownCast(arg1);
75346     } catch (std::out_of_range& e) {
75347       {
75348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75349       };
75350     } catch (std::exception& e) {
75351       {
75352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75353       };
75354     } catch (...) {
75355       {
75356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75357       };
75358     }
75359   }
75360   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75361   return jresult;
75362 }
75363
75364
75365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75366   void * jresult ;
75367   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75368   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75369
75370   arg1 = (Dali::Toolkit::Slider *)jarg1;
75371   {
75372     try {
75373       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75374     } catch (std::out_of_range& e) {
75375       {
75376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75377       };
75378     } catch (std::exception& e) {
75379       {
75380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75385       };
75386     }
75387   }
75388   jresult = (void *)result;
75389   return jresult;
75390 }
75391
75392
75393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75394   void * jresult ;
75395   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75396   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75397
75398   arg1 = (Dali::Toolkit::Slider *)jarg1;
75399   {
75400     try {
75401       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75402     } catch (std::out_of_range& e) {
75403       {
75404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75405       };
75406     } catch (std::exception& e) {
75407       {
75408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75409       };
75410     } catch (...) {
75411       {
75412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75413       };
75414     }
75415   }
75416   jresult = (void *)result;
75417   return jresult;
75418 }
75419
75420
75421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75422   void * jresult ;
75423   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75424   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75425
75426   arg1 = (Dali::Toolkit::Slider *)jarg1;
75427   {
75428     try {
75429       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75430     } catch (std::out_of_range& e) {
75431       {
75432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75433       };
75434     } catch (std::exception& e) {
75435       {
75436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75437       };
75438     } catch (...) {
75439       {
75440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75441       };
75442     }
75443   }
75444   jresult = (void *)result;
75445   return jresult;
75446 }
75447
75448
75449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75450   int jresult ;
75451   int result;
75452
75453   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75454   jresult = (int)result;
75455   return jresult;
75456 }
75457
75458
75459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75460   int jresult ;
75461   int result;
75462
75463   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75464   jresult = (int)result;
75465   return jresult;
75466 }
75467
75468
75469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75470   int jresult ;
75471   int result;
75472
75473   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75474   jresult = (int)result;
75475   return jresult;
75476 }
75477
75478
75479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75480   int jresult ;
75481   int result;
75482
75483   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75484   jresult = (int)result;
75485   return jresult;
75486 }
75487
75488
75489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75490   void * jresult ;
75491   Dali::Toolkit::VideoView::Property *result = 0 ;
75492
75493   {
75494     try {
75495       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75496     } catch (std::out_of_range& e) {
75497       {
75498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75499       };
75500     } catch (std::exception& e) {
75501       {
75502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75503       };
75504     } catch (...) {
75505       {
75506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75507       };
75508     }
75509   }
75510   jresult = (void *)result;
75511   return jresult;
75512 }
75513
75514
75515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75516   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75517
75518   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75519   {
75520     try {
75521       delete arg1;
75522     } catch (std::out_of_range& e) {
75523       {
75524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75525       };
75526     } catch (std::exception& e) {
75527       {
75528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75529       };
75530     } catch (...) {
75531       {
75532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75533       };
75534     }
75535   }
75536 }
75537
75538
75539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75540   void * jresult ;
75541   Dali::Toolkit::VideoView result;
75542
75543   {
75544     try {
75545       result = Dali::Toolkit::VideoView::New();
75546     } catch (std::out_of_range& e) {
75547       {
75548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75549       };
75550     } catch (std::exception& e) {
75551       {
75552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75553       };
75554     } catch (...) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75557       };
75558     }
75559   }
75560   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75561   return jresult;
75562 }
75563
75564
75565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75566   void * jresult ;
75567   std::string *arg1 = 0 ;
75568   Dali::Toolkit::VideoView result;
75569
75570   if (!jarg1) {
75571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75572     return 0;
75573   }
75574   std::string arg1_str(jarg1);
75575   arg1 = &arg1_str;
75576   {
75577     try {
75578       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (...) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75590       };
75591     }
75592   }
75593   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75594
75595   //argout typemap for const std::string&
75596
75597   return jresult;
75598 }
75599
75600
75601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75602   void * jresult ;
75603   Dali::Toolkit::VideoView *result = 0 ;
75604
75605   {
75606     try {
75607       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75608     } catch (std::out_of_range& e) {
75609       {
75610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75611       };
75612     } catch (std::exception& e) {
75613       {
75614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75615       };
75616     } catch (...) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75619       };
75620     }
75621   }
75622   jresult = (void *)result;
75623   return jresult;
75624 }
75625
75626
75627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75628   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75629
75630   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75631   {
75632     try {
75633       delete arg1;
75634     } catch (std::out_of_range& e) {
75635       {
75636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75637       };
75638     } catch (std::exception& e) {
75639       {
75640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75645       };
75646     }
75647   }
75648 }
75649
75650
75651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75652   void * jresult ;
75653   Dali::Toolkit::VideoView *arg1 = 0 ;
75654   Dali::Toolkit::VideoView *result = 0 ;
75655
75656   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75657   if (!arg1) {
75658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75659     return 0;
75660   }
75661   {
75662     try {
75663       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75664     } catch (std::out_of_range& e) {
75665       {
75666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75667       };
75668     } catch (std::exception& e) {
75669       {
75670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75671       };
75672     } catch (...) {
75673       {
75674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75675       };
75676     }
75677   }
75678   jresult = (void *)result;
75679   return jresult;
75680 }
75681
75682
75683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75684   void * jresult ;
75685   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75686   Dali::Toolkit::VideoView *arg2 = 0 ;
75687   Dali::Toolkit::VideoView *result = 0 ;
75688
75689   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75690   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75691   if (!arg2) {
75692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75693     return 0;
75694   }
75695   {
75696     try {
75697       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75698     } catch (std::out_of_range& e) {
75699       {
75700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (std::exception& e) {
75703       {
75704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75705       };
75706     } catch (...) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75709       };
75710     }
75711   }
75712   jresult = (void *)result;
75713   return jresult;
75714 }
75715
75716
75717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75718   void * jresult ;
75719   Dali::BaseHandle arg1 ;
75720   Dali::BaseHandle *argp1 ;
75721   Dali::Toolkit::VideoView result;
75722
75723   argp1 = (Dali::BaseHandle *)jarg1;
75724   if (!argp1) {
75725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75726     return 0;
75727   }
75728   arg1 = *argp1;
75729   {
75730     try {
75731       result = Dali::Toolkit::VideoView::DownCast(arg1);
75732     } catch (std::out_of_range& e) {
75733       {
75734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75735       };
75736     } catch (std::exception& e) {
75737       {
75738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75739       };
75740     } catch (...) {
75741       {
75742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75743       };
75744     }
75745   }
75746   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75747   return jresult;
75748 }
75749
75750
75751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75752   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75753
75754   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75755   {
75756     try {
75757       (arg1)->Play();
75758     } catch (std::out_of_range& e) {
75759       {
75760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75761       };
75762     } catch (std::exception& e) {
75763       {
75764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75765       };
75766     } catch (...) {
75767       {
75768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75769       };
75770     }
75771   }
75772 }
75773
75774
75775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75776   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75777
75778   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75779   {
75780     try {
75781       (arg1)->Pause();
75782     } catch (std::out_of_range& e) {
75783       {
75784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75785       };
75786     } catch (std::exception& e) {
75787       {
75788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75789       };
75790     } catch (...) {
75791       {
75792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75793       };
75794     }
75795   }
75796 }
75797
75798
75799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75800   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75801
75802   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75803   {
75804     try {
75805       (arg1)->Stop();
75806     } catch (std::out_of_range& e) {
75807       {
75808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75809       };
75810     } catch (std::exception& e) {
75811       {
75812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75813       };
75814     } catch (...) {
75815       {
75816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75817       };
75818     }
75819   }
75820 }
75821
75822
75823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75824   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75825   int arg2 ;
75826
75827   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75828   arg2 = (int)jarg2;
75829   {
75830     try {
75831       (arg1)->Forward(arg2);
75832     } catch (std::out_of_range& e) {
75833       {
75834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75835       };
75836     } catch (std::exception& e) {
75837       {
75838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75839       };
75840     } catch (...) {
75841       {
75842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75843       };
75844     }
75845   }
75846 }
75847
75848
75849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
75850   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75851   int arg2 ;
75852
75853   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75854   arg2 = (int)jarg2;
75855   {
75856     try {
75857       (arg1)->Backward(arg2);
75858     } catch (std::out_of_range& e) {
75859       {
75860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75861       };
75862     } catch (std::exception& e) {
75863       {
75864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75865       };
75866     } catch (...) {
75867       {
75868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75869       };
75870     }
75871   }
75872 }
75873
75874
75875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75876   void * jresult ;
75877   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75878   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75879
75880   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75881   {
75882     try {
75883       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75884     } catch (std::out_of_range& e) {
75885       {
75886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75887       };
75888     } catch (std::exception& e) {
75889       {
75890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75891       };
75892     } catch (...) {
75893       {
75894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75895       };
75896     }
75897   }
75898   jresult = (void *)result;
75899   return jresult;
75900 }
75901
75902
75903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75904   int jresult ;
75905   int result;
75906
75907   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75908   jresult = (int)result;
75909   return jresult;
75910 }
75911
75912
75913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75914   int jresult ;
75915   int result;
75916
75917   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75918   jresult = (int)result;
75919   return jresult;
75920 }
75921
75922
75923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75924   int jresult ;
75925   int result;
75926
75927   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75928   jresult = (int)result;
75929   return jresult;
75930 }
75931
75932
75933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75934   int jresult ;
75935   int result;
75936
75937   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75938   jresult = (int)result;
75939   return jresult;
75940 }
75941
75942
75943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75944   int jresult ;
75945   int result;
75946
75947   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75948   jresult = (int)result;
75949   return jresult;
75950 }
75951
75952
75953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75954   int jresult ;
75955   int result;
75956
75957   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
75958   jresult = (int)result;
75959   return jresult;
75960 }
75961
75962
75963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
75964   int jresult ;
75965   int result;
75966
75967   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
75968   jresult = (int)result;
75969   return jresult;
75970 }
75971
75972
75973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
75974   int jresult ;
75975   int result;
75976
75977   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
75978   jresult = (int)result;
75979   return jresult;
75980 }
75981
75982
75983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
75984   int jresult ;
75985   int result;
75986
75987   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
75988   jresult = (int)result;
75989   return jresult;
75990 }
75991
75992
75993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
75994   int jresult ;
75995   int result;
75996
75997   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
75998   jresult = (int)result;
75999   return jresult;
76000 }
76001
76002
76003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76004   int jresult ;
76005   int result;
76006
76007   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76008   jresult = (int)result;
76009   return jresult;
76010 }
76011
76012
76013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76014   int jresult ;
76015   int result;
76016
76017   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76018   jresult = (int)result;
76019   return jresult;
76020 }
76021
76022
76023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76024   int jresult ;
76025   int result;
76026
76027   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76028   jresult = (int)result;
76029   return jresult;
76030 }
76031
76032
76033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76034   int jresult ;
76035   int result;
76036
76037   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76038   jresult = (int)result;
76039   return jresult;
76040 }
76041
76042
76043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76044   int jresult ;
76045   int result;
76046
76047   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76048   jresult = (int)result;
76049   return jresult;
76050 }
76051
76052
76053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76054   int jresult ;
76055   int result;
76056
76057   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76058   jresult = (int)result;
76059   return jresult;
76060 }
76061
76062
76063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76064   int jresult ;
76065   int result;
76066
76067   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76068   jresult = (int)result;
76069   return jresult;
76070 }
76071
76072
76073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76074   int jresult ;
76075   int result;
76076
76077   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76078   jresult = (int)result;
76079   return jresult;
76080 }
76081
76082
76083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76084   int jresult ;
76085   int result;
76086
76087   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76088   jresult = (int)result;
76089   return jresult;
76090 }
76091
76092
76093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76094   int jresult ;
76095   int result;
76096
76097   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76098   jresult = (int)result;
76099   return jresult;
76100 }
76101
76102
76103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76104   int jresult ;
76105   int result;
76106
76107   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76108   jresult = (int)result;
76109   return jresult;
76110 }
76111
76112
76113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76114   void * jresult ;
76115   Dali::Toolkit::Popup::Property *result = 0 ;
76116
76117   {
76118     try {
76119       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76127       };
76128     } catch (...) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76131       };
76132     }
76133   }
76134   jresult = (void *)result;
76135   return jresult;
76136 }
76137
76138
76139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76140   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76141
76142   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76143   {
76144     try {
76145       delete arg1;
76146     } catch (std::out_of_range& e) {
76147       {
76148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76149       };
76150     } catch (std::exception& e) {
76151       {
76152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76153       };
76154     } catch (...) {
76155       {
76156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76157       };
76158     }
76159   }
76160 }
76161
76162
76163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76164   void * jresult ;
76165   Dali::Toolkit::Popup *result = 0 ;
76166
76167   {
76168     try {
76169       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
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_Popup_New() {
76190   void * jresult ;
76191   Dali::Toolkit::Popup result;
76192
76193   {
76194     try {
76195       result = Dali::Toolkit::Popup::New();
76196     } catch (std::out_of_range& e) {
76197       {
76198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76199       };
76200     } catch (std::exception& e) {
76201       {
76202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76203       };
76204     } catch (...) {
76205       {
76206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76207       };
76208     }
76209   }
76210   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76211   return jresult;
76212 }
76213
76214
76215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76216   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76217
76218   arg1 = (Dali::Toolkit::Popup *)jarg1;
76219   {
76220     try {
76221       delete arg1;
76222     } catch (std::out_of_range& e) {
76223       {
76224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76225       };
76226     } catch (std::exception& e) {
76227       {
76228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76229       };
76230     } catch (...) {
76231       {
76232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76233       };
76234     }
76235   }
76236 }
76237
76238
76239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76240   void * jresult ;
76241   Dali::Toolkit::Popup *arg1 = 0 ;
76242   Dali::Toolkit::Popup *result = 0 ;
76243
76244   arg1 = (Dali::Toolkit::Popup *)jarg1;
76245   if (!arg1) {
76246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76247     return 0;
76248   }
76249   {
76250     try {
76251       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76252     } catch (std::out_of_range& e) {
76253       {
76254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76255       };
76256     } catch (std::exception& e) {
76257       {
76258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76259       };
76260     } catch (...) {
76261       {
76262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76263       };
76264     }
76265   }
76266   jresult = (void *)result;
76267   return jresult;
76268 }
76269
76270
76271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76272   void * jresult ;
76273   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76274   Dali::Toolkit::Popup *arg2 = 0 ;
76275   Dali::Toolkit::Popup *result = 0 ;
76276
76277   arg1 = (Dali::Toolkit::Popup *)jarg1;
76278   arg2 = (Dali::Toolkit::Popup *)jarg2;
76279   if (!arg2) {
76280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76281     return 0;
76282   }
76283   {
76284     try {
76285       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76286     } catch (std::out_of_range& e) {
76287       {
76288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76289       };
76290     } catch (std::exception& e) {
76291       {
76292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76293       };
76294     } catch (...) {
76295       {
76296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76297       };
76298     }
76299   }
76300   jresult = (void *)result;
76301   return jresult;
76302 }
76303
76304
76305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76306   void * jresult ;
76307   Dali::BaseHandle arg1 ;
76308   Dali::BaseHandle *argp1 ;
76309   Dali::Toolkit::Popup result;
76310
76311   argp1 = (Dali::BaseHandle *)jarg1;
76312   if (!argp1) {
76313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76314     return 0;
76315   }
76316   arg1 = *argp1;
76317   {
76318     try {
76319       result = Dali::Toolkit::Popup::DownCast(arg1);
76320     } catch (std::out_of_range& e) {
76321       {
76322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76323       };
76324     } catch (std::exception& e) {
76325       {
76326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76327       };
76328     } catch (...) {
76329       {
76330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76331       };
76332     }
76333   }
76334   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76335   return jresult;
76336 }
76337
76338
76339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76340   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76341   Dali::Actor arg2 ;
76342   Dali::Actor *argp2 ;
76343
76344   arg1 = (Dali::Toolkit::Popup *)jarg1;
76345   argp2 = (Dali::Actor *)jarg2;
76346   if (!argp2) {
76347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76348     return ;
76349   }
76350   arg2 = *argp2;
76351   {
76352     try {
76353       (arg1)->SetTitle(arg2);
76354     } catch (std::out_of_range& e) {
76355       {
76356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76357       };
76358     } catch (std::exception& e) {
76359       {
76360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76361       };
76362     } catch (...) {
76363       {
76364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76365       };
76366     }
76367   }
76368 }
76369
76370
76371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76372   void * jresult ;
76373   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76374   Dali::Actor result;
76375
76376   arg1 = (Dali::Toolkit::Popup *)jarg1;
76377   {
76378     try {
76379       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76380     } catch (std::out_of_range& e) {
76381       {
76382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76383       };
76384     } catch (std::exception& e) {
76385       {
76386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76387       };
76388     } catch (...) {
76389       {
76390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76391       };
76392     }
76393   }
76394   jresult = new Dali::Actor((const Dali::Actor &)result);
76395   return jresult;
76396 }
76397
76398
76399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76400   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76401   Dali::Actor arg2 ;
76402   Dali::Actor *argp2 ;
76403
76404   arg1 = (Dali::Toolkit::Popup *)jarg1;
76405   argp2 = (Dali::Actor *)jarg2;
76406   if (!argp2) {
76407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76408     return ;
76409   }
76410   arg2 = *argp2;
76411   {
76412     try {
76413       (arg1)->SetContent(arg2);
76414     } catch (std::out_of_range& e) {
76415       {
76416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76417       };
76418     } catch (std::exception& e) {
76419       {
76420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76421       };
76422     } catch (...) {
76423       {
76424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76425       };
76426     }
76427   }
76428 }
76429
76430
76431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76432   void * jresult ;
76433   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76434   Dali::Actor result;
76435
76436   arg1 = (Dali::Toolkit::Popup *)jarg1;
76437   {
76438     try {
76439       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76440     } catch (std::out_of_range& e) {
76441       {
76442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76443       };
76444     } catch (std::exception& e) {
76445       {
76446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76447       };
76448     } catch (...) {
76449       {
76450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76451       };
76452     }
76453   }
76454   jresult = new Dali::Actor((const Dali::Actor &)result);
76455   return jresult;
76456 }
76457
76458
76459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76460   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76461   Dali::Actor arg2 ;
76462   Dali::Actor *argp2 ;
76463
76464   arg1 = (Dali::Toolkit::Popup *)jarg1;
76465   argp2 = (Dali::Actor *)jarg2;
76466   if (!argp2) {
76467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76468     return ;
76469   }
76470   arg2 = *argp2;
76471   {
76472     try {
76473       (arg1)->SetFooter(arg2);
76474     } catch (std::out_of_range& e) {
76475       {
76476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76477       };
76478     } catch (std::exception& e) {
76479       {
76480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76481       };
76482     } catch (...) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76485       };
76486     }
76487   }
76488 }
76489
76490
76491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76492   void * jresult ;
76493   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76494   Dali::Actor result;
76495
76496   arg1 = (Dali::Toolkit::Popup *)jarg1;
76497   {
76498     try {
76499       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76500     } catch (std::out_of_range& e) {
76501       {
76502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76503       };
76504     } catch (std::exception& e) {
76505       {
76506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76507       };
76508     } catch (...) {
76509       {
76510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76511       };
76512     }
76513   }
76514   jresult = new Dali::Actor((const Dali::Actor &)result);
76515   return jresult;
76516 }
76517
76518
76519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76520   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76521   Dali::Toolkit::Popup::DisplayState arg2 ;
76522
76523   arg1 = (Dali::Toolkit::Popup *)jarg1;
76524   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76525   {
76526     try {
76527       (arg1)->SetDisplayState(arg2);
76528     } catch (std::out_of_range& e) {
76529       {
76530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76531       };
76532     } catch (std::exception& e) {
76533       {
76534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76535       };
76536     } catch (...) {
76537       {
76538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76539       };
76540     }
76541   }
76542 }
76543
76544
76545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76546   int jresult ;
76547   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76548   Dali::Toolkit::Popup::DisplayState result;
76549
76550   arg1 = (Dali::Toolkit::Popup *)jarg1;
76551   {
76552     try {
76553       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76554     } catch (std::out_of_range& e) {
76555       {
76556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76557       };
76558     } catch (std::exception& e) {
76559       {
76560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76561       };
76562     } catch (...) {
76563       {
76564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76565       };
76566     }
76567   }
76568   jresult = (int)result;
76569   return jresult;
76570 }
76571
76572
76573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76574   void * jresult ;
76575   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76576   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76577
76578   arg1 = (Dali::Toolkit::Popup *)jarg1;
76579   {
76580     try {
76581       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76582     } catch (std::out_of_range& e) {
76583       {
76584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76585       };
76586     } catch (std::exception& e) {
76587       {
76588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76589       };
76590     } catch (...) {
76591       {
76592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76593       };
76594     }
76595   }
76596   jresult = (void *)result;
76597   return jresult;
76598 }
76599
76600
76601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76602   void * jresult ;
76603   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76604   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76605
76606   arg1 = (Dali::Toolkit::Popup *)jarg1;
76607   {
76608     try {
76609       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76610     } catch (std::out_of_range& e) {
76611       {
76612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76613       };
76614     } catch (std::exception& e) {
76615       {
76616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76617       };
76618     } catch (...) {
76619       {
76620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76621       };
76622     }
76623   }
76624   jresult = (void *)result;
76625   return jresult;
76626 }
76627
76628
76629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76630   void * jresult ;
76631   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76632   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76633
76634   arg1 = (Dali::Toolkit::Popup *)jarg1;
76635   {
76636     try {
76637       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76638     } catch (std::out_of_range& e) {
76639       {
76640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76641       };
76642     } catch (std::exception& e) {
76643       {
76644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76645       };
76646     } catch (...) {
76647       {
76648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76649       };
76650     }
76651   }
76652   jresult = (void *)result;
76653   return jresult;
76654 }
76655
76656
76657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76658   void * jresult ;
76659   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76660   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76661
76662   arg1 = (Dali::Toolkit::Popup *)jarg1;
76663   {
76664     try {
76665       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76666     } catch (std::out_of_range& e) {
76667       {
76668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76669       };
76670     } catch (std::exception& e) {
76671       {
76672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76673       };
76674     } catch (...) {
76675       {
76676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76677       };
76678     }
76679   }
76680   jresult = (void *)result;
76681   return jresult;
76682 }
76683
76684
76685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76686   void * jresult ;
76687   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76688   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76689
76690   arg1 = (Dali::Toolkit::Popup *)jarg1;
76691   {
76692     try {
76693       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76694     } catch (std::out_of_range& e) {
76695       {
76696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76697       };
76698     } catch (std::exception& e) {
76699       {
76700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76701       };
76702     } catch (...) {
76703       {
76704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76705       };
76706     }
76707   }
76708   jresult = (void *)result;
76709   return jresult;
76710 }
76711
76712
76713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76714   int jresult ;
76715   int result;
76716
76717   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76718   jresult = (int)result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76724   int jresult ;
76725   int result;
76726
76727   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76728   jresult = (int)result;
76729   return jresult;
76730 }
76731
76732
76733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76734   int jresult ;
76735   int result;
76736
76737   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76738   jresult = (int)result;
76739   return jresult;
76740 }
76741
76742
76743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76744   int jresult ;
76745   int result;
76746
76747   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76748   jresult = (int)result;
76749   return jresult;
76750 }
76751
76752
76753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76754   int jresult ;
76755   int result;
76756
76757   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76758   jresult = (int)result;
76759   return jresult;
76760 }
76761
76762
76763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76764   int jresult ;
76765   int result;
76766
76767   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76768   jresult = (int)result;
76769   return jresult;
76770 }
76771
76772
76773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76774   int jresult ;
76775   int result;
76776
76777   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76778   jresult = (int)result;
76779   return jresult;
76780 }
76781
76782
76783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76784   int jresult ;
76785   int result;
76786
76787   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76788   jresult = (int)result;
76789   return jresult;
76790 }
76791
76792
76793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76794   int jresult ;
76795   int result;
76796
76797   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76798   jresult = (int)result;
76799   return jresult;
76800 }
76801
76802
76803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76804   void * jresult ;
76805   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76806
76807   {
76808     try {
76809       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76810     } catch (std::out_of_range& e) {
76811       {
76812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76813       };
76814     } catch (std::exception& e) {
76815       {
76816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76817       };
76818     } catch (...) {
76819       {
76820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76821       };
76822     }
76823   }
76824   jresult = (void *)result;
76825   return jresult;
76826 }
76827
76828
76829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
76830   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76831
76832   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76833   {
76834     try {
76835       delete arg1;
76836     } catch (std::out_of_range& e) {
76837       {
76838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76839       };
76840     } catch (std::exception& e) {
76841       {
76842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76843       };
76844     } catch (...) {
76845       {
76846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76847       };
76848     }
76849   }
76850 }
76851
76852
76853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76854   void * jresult ;
76855   Dali::Toolkit::ProgressBar result;
76856
76857   {
76858     try {
76859       result = Dali::Toolkit::ProgressBar::New();
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76867       };
76868     } catch (...) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76871       };
76872     }
76873   }
76874   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76875   return jresult;
76876 }
76877
76878
76879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76880   void * jresult ;
76881   Dali::Toolkit::ProgressBar *result = 0 ;
76882
76883   {
76884     try {
76885       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76886     } catch (std::out_of_range& e) {
76887       {
76888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76889       };
76890     } catch (std::exception& e) {
76891       {
76892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76893       };
76894     } catch (...) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76897       };
76898     }
76899   }
76900   jresult = (void *)result;
76901   return jresult;
76902 }
76903
76904
76905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76906   void * jresult ;
76907   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76908   Dali::Toolkit::ProgressBar *result = 0 ;
76909
76910   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76911   if (!arg1) {
76912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76913     return 0;
76914   }
76915   {
76916     try {
76917       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76918     } catch (std::out_of_range& e) {
76919       {
76920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76921       };
76922     } catch (std::exception& e) {
76923       {
76924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76925       };
76926     } catch (...) {
76927       {
76928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76929       };
76930     }
76931   }
76932   jresult = (void *)result;
76933   return jresult;
76934 }
76935
76936
76937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76938   void * jresult ;
76939   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76940   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76941   Dali::Toolkit::ProgressBar *result = 0 ;
76942
76943   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76944   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76945   if (!arg2) {
76946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76947     return 0;
76948   }
76949   {
76950     try {
76951       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
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_ProgressBar(void * jarg1) {
76972   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76973
76974   arg1 = (Dali::Toolkit::ProgressBar *)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_ProgressBar_DownCast(void * jarg1) {
76996   void * jresult ;
76997   Dali::BaseHandle arg1 ;
76998   Dali::BaseHandle *argp1 ;
76999   Dali::Toolkit::ProgressBar result;
77000
77001   argp1 = (Dali::BaseHandle *)jarg1;
77002   if (!argp1) {
77003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77004     return 0;
77005   }
77006   arg1 = *argp1;
77007   {
77008     try {
77009       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77010     } catch (std::out_of_range& e) {
77011       {
77012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77013       };
77014     } catch (std::exception& e) {
77015       {
77016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77017       };
77018     } catch (...) {
77019       {
77020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77021       };
77022     }
77023   }
77024   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77025   return jresult;
77026 }
77027
77028
77029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77030   void * jresult ;
77031   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77032   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77033
77034   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77035   {
77036     try {
77037       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77038     } catch (std::out_of_range& e) {
77039       {
77040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77041       };
77042     } catch (std::exception& e) {
77043       {
77044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77045       };
77046     } catch (...) {
77047       {
77048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77049       };
77050     }
77051   }
77052   jresult = (void *)result;
77053   return jresult;
77054 }
77055
77056
77057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77058   void * jresult ;
77059   Dali::Toolkit::GaussianBlurView *result = 0 ;
77060
77061   {
77062     try {
77063       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77064     } catch (std::out_of_range& e) {
77065       {
77066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77067       };
77068     } catch (std::exception& e) {
77069       {
77070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77071       };
77072     } catch (...) {
77073       {
77074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77075       };
77076     }
77077   }
77078   jresult = (void *)result;
77079   return jresult;
77080 }
77081
77082
77083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77084   void * jresult ;
77085   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77086   Dali::Toolkit::GaussianBlurView *result = 0 ;
77087
77088   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77089   if (!arg1) {
77090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77091     return 0;
77092   }
77093   {
77094     try {
77095       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77096     } catch (std::out_of_range& e) {
77097       {
77098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77099       };
77100     } catch (std::exception& e) {
77101       {
77102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77103       };
77104     } catch (...) {
77105       {
77106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77107       };
77108     }
77109   }
77110   jresult = (void *)result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77116   void * jresult ;
77117   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77118   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77119   Dali::Toolkit::GaussianBlurView *result = 0 ;
77120
77121   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77122   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77123   if (!arg2) {
77124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77125     return 0;
77126   }
77127   {
77128     try {
77129       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77130     } catch (std::out_of_range& e) {
77131       {
77132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77133       };
77134     } catch (std::exception& e) {
77135       {
77136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77137       };
77138     } catch (...) {
77139       {
77140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77141       };
77142     }
77143   }
77144   jresult = (void *)result;
77145   return jresult;
77146 }
77147
77148
77149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77150   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77151
77152   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77153   {
77154     try {
77155       delete arg1;
77156     } catch (std::out_of_range& e) {
77157       {
77158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77159       };
77160     } catch (std::exception& e) {
77161       {
77162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77163       };
77164     } catch (...) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77167       };
77168     }
77169   }
77170 }
77171
77172
77173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77174   void * jresult ;
77175   Dali::BaseHandle arg1 ;
77176   Dali::BaseHandle *argp1 ;
77177   Dali::Toolkit::GaussianBlurView result;
77178
77179   argp1 = (Dali::BaseHandle *)jarg1;
77180   if (!argp1) {
77181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77182     return 0;
77183   }
77184   arg1 = *argp1;
77185   {
77186     try {
77187       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77188     } catch (std::out_of_range& e) {
77189       {
77190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77191       };
77192     } catch (std::exception& e) {
77193       {
77194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77195       };
77196     } catch (...) {
77197       {
77198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77199       };
77200     }
77201   }
77202   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77203   return jresult;
77204 }
77205
77206
77207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77208   void * jresult ;
77209   Dali::Toolkit::GaussianBlurView result;
77210
77211   {
77212     try {
77213       result = Dali::Toolkit::GaussianBlurView::New();
77214     } catch (std::out_of_range& e) {
77215       {
77216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77217       };
77218     } catch (std::exception& e) {
77219       {
77220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (...) {
77223       {
77224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77225       };
77226     }
77227   }
77228   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77229   return jresult;
77230 }
77231
77232
77233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77234   void * jresult ;
77235   unsigned int arg1 ;
77236   float arg2 ;
77237   Dali::Pixel::Format arg3 ;
77238   float arg4 ;
77239   float arg5 ;
77240   bool arg6 ;
77241   Dali::Toolkit::GaussianBlurView result;
77242
77243   arg1 = (unsigned int)jarg1;
77244   arg2 = (float)jarg2;
77245   arg3 = (Dali::Pixel::Format)jarg3;
77246   arg4 = (float)jarg4;
77247   arg5 = (float)jarg5;
77248   arg6 = jarg6 ? true : false;
77249   {
77250     try {
77251       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77252     } catch (std::out_of_range& e) {
77253       {
77254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77255       };
77256     } catch (std::exception& e) {
77257       {
77258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77259       };
77260     } catch (...) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77263       };
77264     }
77265   }
77266   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77267   return jresult;
77268 }
77269
77270
77271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77272   void * jresult ;
77273   unsigned int arg1 ;
77274   float arg2 ;
77275   Dali::Pixel::Format arg3 ;
77276   float arg4 ;
77277   float arg5 ;
77278   Dali::Toolkit::GaussianBlurView result;
77279
77280   arg1 = (unsigned int)jarg1;
77281   arg2 = (float)jarg2;
77282   arg3 = (Dali::Pixel::Format)jarg3;
77283   arg4 = (float)jarg4;
77284   arg5 = (float)jarg5;
77285   {
77286     try {
77287       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77288     } catch (std::out_of_range& e) {
77289       {
77290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77291       };
77292     } catch (std::exception& e) {
77293       {
77294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77295       };
77296     } catch (...) {
77297       {
77298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77299       };
77300     }
77301   }
77302   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77303   return jresult;
77304 }
77305
77306
77307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77308   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77309   Dali::Actor arg2 ;
77310   Dali::Actor *argp2 ;
77311
77312   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77313   argp2 = (Dali::Actor *)jarg2;
77314   if (!argp2) {
77315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77316     return ;
77317   }
77318   arg2 = *argp2;
77319   {
77320     try {
77321       (arg1)->Add(arg2);
77322     } catch (std::out_of_range& e) {
77323       {
77324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77325       };
77326     } catch (std::exception& e) {
77327       {
77328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77329       };
77330     } catch (...) {
77331       {
77332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77333       };
77334     }
77335   }
77336 }
77337
77338
77339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77340   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77341   Dali::Actor arg2 ;
77342   Dali::Actor *argp2 ;
77343
77344   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77345   argp2 = (Dali::Actor *)jarg2;
77346   if (!argp2) {
77347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77348     return ;
77349   }
77350   arg2 = *argp2;
77351   {
77352     try {
77353       (arg1)->Remove(arg2);
77354     } catch (std::out_of_range& e) {
77355       {
77356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77357       };
77358     } catch (std::exception& e) {
77359       {
77360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77361       };
77362     } catch (...) {
77363       {
77364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77365       };
77366     }
77367   }
77368 }
77369
77370
77371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77372   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77373
77374   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77375   {
77376     try {
77377       (arg1)->Activate();
77378     } catch (std::out_of_range& e) {
77379       {
77380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77381       };
77382     } catch (std::exception& e) {
77383       {
77384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77385       };
77386     } catch (...) {
77387       {
77388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77389       };
77390     }
77391   }
77392 }
77393
77394
77395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77396   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77397
77398   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77399   {
77400     try {
77401       (arg1)->ActivateOnce();
77402     } catch (std::out_of_range& e) {
77403       {
77404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77405       };
77406     } catch (std::exception& e) {
77407       {
77408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77409       };
77410     } catch (...) {
77411       {
77412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77413       };
77414     }
77415   }
77416 }
77417
77418
77419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77420   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77421
77422   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77423   {
77424     try {
77425       (arg1)->Deactivate();
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_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77444   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77445   Dali::Image arg2 ;
77446   Dali::FrameBufferImage arg3 ;
77447   Dali::Image *argp2 ;
77448   Dali::FrameBufferImage *argp3 ;
77449
77450   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77451   argp2 = (Dali::Image *)jarg2;
77452   if (!argp2) {
77453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77454     return ;
77455   }
77456   arg2 = *argp2;
77457   argp3 = (Dali::FrameBufferImage *)jarg3;
77458   if (!argp3) {
77459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77460     return ;
77461   }
77462   arg3 = *argp3;
77463   {
77464     try {
77465       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77466     } catch (std::out_of_range& e) {
77467       {
77468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77469       };
77470     } catch (std::exception& e) {
77471       {
77472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77473       };
77474     } catch (...) {
77475       {
77476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77477       };
77478     }
77479   }
77480 }
77481
77482
77483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77484   int jresult ;
77485   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77486   Dali::Property::Index result;
77487
77488   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77489   {
77490     try {
77491       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77492     } catch (std::out_of_range& e) {
77493       {
77494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77495       };
77496     } catch (std::exception& e) {
77497       {
77498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77499       };
77500     } catch (...) {
77501       {
77502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77503       };
77504     }
77505   }
77506   jresult = result;
77507   return jresult;
77508 }
77509
77510
77511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77512   void * jresult ;
77513   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77514   Dali::FrameBufferImage result;
77515
77516   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77517   {
77518     try {
77519       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77520     } catch (std::out_of_range& e) {
77521       {
77522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77523       };
77524     } catch (std::exception& e) {
77525       {
77526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77527       };
77528     } catch (...) {
77529       {
77530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77531       };
77532     }
77533   }
77534   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77535   return jresult;
77536 }
77537
77538
77539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77540   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77541   Dali::Vector4 *arg2 = 0 ;
77542
77543   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77544   arg2 = (Dali::Vector4 *)jarg2;
77545   if (!arg2) {
77546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77547     return ;
77548   }
77549   {
77550     try {
77551       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77552     } catch (std::out_of_range& e) {
77553       {
77554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77555       };
77556     } catch (std::exception& e) {
77557       {
77558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77559       };
77560     } catch (...) {
77561       {
77562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77563       };
77564     }
77565   }
77566 }
77567
77568
77569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77570   void * jresult ;
77571   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77572   Dali::Vector4 result;
77573
77574   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77575   {
77576     try {
77577       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77578     } catch (std::out_of_range& e) {
77579       {
77580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77581       };
77582     } catch (std::exception& e) {
77583       {
77584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77585       };
77586     } catch (...) {
77587       {
77588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77589       };
77590     }
77591   }
77592   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77593   return jresult;
77594 }
77595
77596
77597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77598   void * jresult ;
77599   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77600   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77601
77602   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77603   {
77604     try {
77605       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77613       };
77614     } catch (...) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77617       };
77618     }
77619   }
77620   jresult = (void *)result;
77621   return jresult;
77622 }
77623
77624
77625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77626   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77627
77628   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77629   {
77630     try {
77631       delete arg1;
77632     } catch (std::out_of_range& e) {
77633       {
77634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77635       };
77636     } catch (std::exception& e) {
77637       {
77638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77639       };
77640     } catch (...) {
77641       {
77642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77643       };
77644     }
77645   }
77646 }
77647
77648
77649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77650   unsigned int jresult ;
77651   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77652   unsigned int result;
77653
77654   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77655   {
77656     try {
77657       result = (unsigned int)(arg1)->GetNumberOfPages();
77658     } catch (std::out_of_range& e) {
77659       {
77660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77661       };
77662     } catch (std::exception& e) {
77663       {
77664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77665       };
77666     } catch (...) {
77667       {
77668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77669       };
77670     }
77671   }
77672   jresult = result;
77673   return jresult;
77674 }
77675
77676
77677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77678   void * jresult ;
77679   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77680   unsigned int arg2 ;
77681   Dali::Texture result;
77682
77683   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77684   arg2 = (unsigned int)jarg2;
77685   {
77686     try {
77687       result = (arg1)->NewPage(arg2);
77688     } catch (std::out_of_range& e) {
77689       {
77690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77691       };
77692     } catch (std::exception& e) {
77693       {
77694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77695       };
77696     } catch (...) {
77697       {
77698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77699       };
77700     }
77701   }
77702   jresult = new Dali::Texture((const Dali::Texture &)result);
77703   return jresult;
77704 }
77705
77706
77707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77708   int jresult ;
77709   int result;
77710
77711   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77712   jresult = (int)result;
77713   return jresult;
77714 }
77715
77716
77717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77718   int jresult ;
77719   int result;
77720
77721   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77722   jresult = (int)result;
77723   return jresult;
77724 }
77725
77726
77727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77728   int jresult ;
77729   int result;
77730
77731   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77732   jresult = (int)result;
77733   return jresult;
77734 }
77735
77736
77737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77738   void * jresult ;
77739   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77740
77741   {
77742     try {
77743       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77755       };
77756     }
77757   }
77758   jresult = (void *)result;
77759   return jresult;
77760 }
77761
77762
77763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77764   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77765
77766   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77767   {
77768     try {
77769       delete arg1;
77770     } catch (std::out_of_range& e) {
77771       {
77772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77773       };
77774     } catch (std::exception& e) {
77775       {
77776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77777       };
77778     } catch (...) {
77779       {
77780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77781       };
77782     }
77783   }
77784 }
77785
77786
77787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77788   void * jresult ;
77789   Dali::Toolkit::PageTurnView *result = 0 ;
77790
77791   {
77792     try {
77793       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77794     } catch (std::out_of_range& e) {
77795       {
77796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77797       };
77798     } catch (std::exception& e) {
77799       {
77800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77801       };
77802     } catch (...) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77805       };
77806     }
77807   }
77808   jresult = (void *)result;
77809   return jresult;
77810 }
77811
77812
77813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77814   void * jresult ;
77815   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77816   Dali::Toolkit::PageTurnView *result = 0 ;
77817
77818   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77819   if (!arg1) {
77820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77821     return 0;
77822   }
77823   {
77824     try {
77825       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77826     } catch (std::out_of_range& e) {
77827       {
77828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77829       };
77830     } catch (std::exception& e) {
77831       {
77832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77833       };
77834     } catch (...) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77837       };
77838     }
77839   }
77840   jresult = (void *)result;
77841   return jresult;
77842 }
77843
77844
77845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77846   void * jresult ;
77847   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77848   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77849   Dali::Toolkit::PageTurnView *result = 0 ;
77850
77851   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77852   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77853   if (!arg2) {
77854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77855     return 0;
77856   }
77857   {
77858     try {
77859       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77860     } catch (std::out_of_range& e) {
77861       {
77862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77863       };
77864     } catch (std::exception& e) {
77865       {
77866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77867       };
77868     } catch (...) {
77869       {
77870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77871       };
77872     }
77873   }
77874   jresult = (void *)result;
77875   return jresult;
77876 }
77877
77878
77879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77880   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77881
77882   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77883   {
77884     try {
77885       delete arg1;
77886     } catch (std::out_of_range& e) {
77887       {
77888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77889       };
77890     } catch (std::exception& e) {
77891       {
77892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77893       };
77894     } catch (...) {
77895       {
77896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77897       };
77898     }
77899   }
77900 }
77901
77902
77903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77904   void * jresult ;
77905   Dali::BaseHandle arg1 ;
77906   Dali::BaseHandle *argp1 ;
77907   Dali::Toolkit::PageTurnView result;
77908
77909   argp1 = (Dali::BaseHandle *)jarg1;
77910   if (!argp1) {
77911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77912     return 0;
77913   }
77914   arg1 = *argp1;
77915   {
77916     try {
77917       result = Dali::Toolkit::PageTurnView::DownCast(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 = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77933   return jresult;
77934 }
77935
77936
77937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77938   void * jresult ;
77939   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77940   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77941
77942   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77943   {
77944     try {
77945       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77946     } catch (std::out_of_range& e) {
77947       {
77948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77949       };
77950     } catch (std::exception& e) {
77951       {
77952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77953       };
77954     } catch (...) {
77955       {
77956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77957       };
77958     }
77959   }
77960   jresult = (void *)result;
77961   return jresult;
77962 }
77963
77964
77965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
77966   void * jresult ;
77967   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77968   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77969
77970   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77971   {
77972     try {
77973       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
77974     } catch (std::out_of_range& e) {
77975       {
77976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77977       };
77978     } catch (std::exception& e) {
77979       {
77980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77981       };
77982     } catch (...) {
77983       {
77984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77985       };
77986     }
77987   }
77988   jresult = (void *)result;
77989   return jresult;
77990 }
77991
77992
77993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
77994   void * jresult ;
77995   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77996   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
77997
77998   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77999   {
78000     try {
78001       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78002     } catch (std::out_of_range& e) {
78003       {
78004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78005       };
78006     } catch (std::exception& e) {
78007       {
78008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78009       };
78010     } catch (...) {
78011       {
78012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78013       };
78014     }
78015   }
78016   jresult = (void *)result;
78017   return jresult;
78018 }
78019
78020
78021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78022   void * jresult ;
78023   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78024   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78025
78026   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78027   {
78028     try {
78029       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78030     } catch (std::out_of_range& e) {
78031       {
78032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78033       };
78034     } catch (std::exception& e) {
78035       {
78036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78037       };
78038     } catch (...) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78041       };
78042     }
78043   }
78044   jresult = (void *)result;
78045   return jresult;
78046 }
78047
78048
78049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78050   void * jresult ;
78051   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78052
78053   {
78054     try {
78055       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78056     } catch (std::out_of_range& e) {
78057       {
78058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78059       };
78060     } catch (std::exception& e) {
78061       {
78062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78063       };
78064     } catch (...) {
78065       {
78066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78067       };
78068     }
78069   }
78070   jresult = (void *)result;
78071   return jresult;
78072 }
78073
78074
78075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78076   void * jresult ;
78077   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78078   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78079
78080   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78081   if (!arg1) {
78082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78083     return 0;
78084   }
78085   {
78086     try {
78087       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78088     } catch (std::out_of_range& e) {
78089       {
78090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78091       };
78092     } catch (std::exception& e) {
78093       {
78094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78095       };
78096     } catch (...) {
78097       {
78098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78099       };
78100     }
78101   }
78102   jresult = (void *)result;
78103   return jresult;
78104 }
78105
78106
78107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78108   void * jresult ;
78109   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78110   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78111   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78112
78113   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78114   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78115   if (!arg2) {
78116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78117     return 0;
78118   }
78119   {
78120     try {
78121       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78122     } catch (std::out_of_range& e) {
78123       {
78124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78125       };
78126     } catch (std::exception& e) {
78127       {
78128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78129       };
78130     } catch (...) {
78131       {
78132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78133       };
78134     }
78135   }
78136   jresult = (void *)result;
78137   return jresult;
78138 }
78139
78140
78141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78142   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78143
78144   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78145   {
78146     try {
78147       delete arg1;
78148     } catch (std::out_of_range& e) {
78149       {
78150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78151       };
78152     } catch (std::exception& e) {
78153       {
78154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78159       };
78160     }
78161   }
78162 }
78163
78164
78165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78166   void * jresult ;
78167   Dali::Toolkit::PageFactory *arg1 = 0 ;
78168   Dali::Vector2 *arg2 = 0 ;
78169   Dali::Toolkit::PageTurnLandscapeView result;
78170
78171   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78172   if (!arg1) {
78173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78174     return 0;
78175   }
78176   arg2 = (Dali::Vector2 *)jarg2;
78177   if (!arg2) {
78178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78179     return 0;
78180   }
78181   {
78182     try {
78183       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78184     } catch (std::out_of_range& e) {
78185       {
78186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78187       };
78188     } catch (std::exception& e) {
78189       {
78190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78191       };
78192     } catch (...) {
78193       {
78194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78195       };
78196     }
78197   }
78198   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78199   return jresult;
78200 }
78201
78202
78203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78204   void * jresult ;
78205   Dali::BaseHandle arg1 ;
78206   Dali::BaseHandle *argp1 ;
78207   Dali::Toolkit::PageTurnLandscapeView result;
78208
78209   argp1 = (Dali::BaseHandle *)jarg1;
78210   if (!argp1) {
78211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78212     return 0;
78213   }
78214   arg1 = *argp1;
78215   {
78216     try {
78217       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78218     } catch (std::out_of_range& e) {
78219       {
78220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78221       };
78222     } catch (std::exception& e) {
78223       {
78224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78225       };
78226     } catch (...) {
78227       {
78228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78229       };
78230     }
78231   }
78232   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78233   return jresult;
78234 }
78235
78236
78237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78238   void * jresult ;
78239   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78240
78241   {
78242     try {
78243       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78244     } catch (std::out_of_range& e) {
78245       {
78246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78247       };
78248     } catch (std::exception& e) {
78249       {
78250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78251       };
78252     } catch (...) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78255       };
78256     }
78257   }
78258   jresult = (void *)result;
78259   return jresult;
78260 }
78261
78262
78263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78264   void * jresult ;
78265   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78266   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78267
78268   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78269   if (!arg1) {
78270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78271     return 0;
78272   }
78273   {
78274     try {
78275       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78276     } catch (std::out_of_range& e) {
78277       {
78278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78279       };
78280     } catch (std::exception& e) {
78281       {
78282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78283       };
78284     } catch (...) {
78285       {
78286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78287       };
78288     }
78289   }
78290   jresult = (void *)result;
78291   return jresult;
78292 }
78293
78294
78295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78296   void * jresult ;
78297   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78298   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78299   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78300
78301   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78302   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78303   if (!arg2) {
78304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78305     return 0;
78306   }
78307   {
78308     try {
78309       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78310     } catch (std::out_of_range& e) {
78311       {
78312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78313       };
78314     } catch (std::exception& e) {
78315       {
78316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78317       };
78318     } catch (...) {
78319       {
78320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78321       };
78322     }
78323   }
78324   jresult = (void *)result;
78325   return jresult;
78326 }
78327
78328
78329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78330   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78331
78332   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78333   {
78334     try {
78335       delete arg1;
78336     } catch (std::out_of_range& e) {
78337       {
78338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78339       };
78340     } catch (std::exception& e) {
78341       {
78342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78343       };
78344     } catch (...) {
78345       {
78346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78347       };
78348     }
78349   }
78350 }
78351
78352
78353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78354   void * jresult ;
78355   Dali::Toolkit::PageFactory *arg1 = 0 ;
78356   Dali::Vector2 *arg2 = 0 ;
78357   Dali::Toolkit::PageTurnPortraitView result;
78358
78359   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78360   if (!arg1) {
78361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78362     return 0;
78363   }
78364   arg2 = (Dali::Vector2 *)jarg2;
78365   if (!arg2) {
78366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78367     return 0;
78368   }
78369   {
78370     try {
78371       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78372     } catch (std::out_of_range& e) {
78373       {
78374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78375       };
78376     } catch (std::exception& e) {
78377       {
78378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (...) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78383       };
78384     }
78385   }
78386   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78387   return jresult;
78388 }
78389
78390
78391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78392   void * jresult ;
78393   Dali::BaseHandle arg1 ;
78394   Dali::BaseHandle *argp1 ;
78395   Dali::Toolkit::PageTurnPortraitView result;
78396
78397   argp1 = (Dali::BaseHandle *)jarg1;
78398   if (!argp1) {
78399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78400     return 0;
78401   }
78402   arg1 = *argp1;
78403   {
78404     try {
78405       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78406     } catch (std::out_of_range& e) {
78407       {
78408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78409       };
78410     } catch (std::exception& e) {
78411       {
78412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78413       };
78414     } catch (...) {
78415       {
78416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78417       };
78418     }
78419   }
78420   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78421   return jresult;
78422 }
78423
78424
78425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78426   int jresult ;
78427   int result;
78428
78429   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78430   jresult = (int)result;
78431   return jresult;
78432 }
78433
78434
78435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78436   int jresult ;
78437   int result;
78438
78439   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78440   jresult = (int)result;
78441   return jresult;
78442 }
78443
78444
78445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78446   int jresult ;
78447   int result;
78448
78449   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78450   jresult = (int)result;
78451   return jresult;
78452 }
78453
78454
78455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78456   void * jresult ;
78457   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78458
78459   {
78460     try {
78461       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78462     } catch (std::out_of_range& e) {
78463       {
78464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78465       };
78466     } catch (std::exception& e) {
78467       {
78468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78469       };
78470     } catch (...) {
78471       {
78472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78473       };
78474     }
78475   }
78476   jresult = (void *)result;
78477   return jresult;
78478 }
78479
78480
78481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78482   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78483
78484   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78485   {
78486     try {
78487       delete arg1;
78488     } catch (std::out_of_range& e) {
78489       {
78490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78491       };
78492     } catch (std::exception& e) {
78493       {
78494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78495       };
78496     } catch (...) {
78497       {
78498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78499       };
78500     }
78501   }
78502 }
78503
78504
78505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78506   void * jresult ;
78507   Dali::Toolkit::ToggleButton *result = 0 ;
78508
78509   {
78510     try {
78511       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78512     } catch (std::out_of_range& e) {
78513       {
78514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78515       };
78516     } catch (std::exception& e) {
78517       {
78518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78519       };
78520     } catch (...) {
78521       {
78522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78523       };
78524     }
78525   }
78526   jresult = (void *)result;
78527   return jresult;
78528 }
78529
78530
78531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78532   void * jresult ;
78533   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78534   Dali::Toolkit::ToggleButton *result = 0 ;
78535
78536   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78537   if (!arg1) {
78538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78539     return 0;
78540   }
78541   {
78542     try {
78543       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78544     } catch (std::out_of_range& e) {
78545       {
78546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78547       };
78548     } catch (std::exception& e) {
78549       {
78550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78551       };
78552     } catch (...) {
78553       {
78554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78555       };
78556     }
78557   }
78558   jresult = (void *)result;
78559   return jresult;
78560 }
78561
78562
78563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78564   void * jresult ;
78565   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78566   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78567   Dali::Toolkit::ToggleButton *result = 0 ;
78568
78569   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78570   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78571   if (!arg2) {
78572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78573     return 0;
78574   }
78575   {
78576     try {
78577       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78578     } catch (std::out_of_range& e) {
78579       {
78580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (std::exception& e) {
78583       {
78584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78585       };
78586     } catch (...) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78589       };
78590     }
78591   }
78592   jresult = (void *)result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78598   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78599
78600   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78601   {
78602     try {
78603       delete arg1;
78604     } catch (std::out_of_range& e) {
78605       {
78606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78607       };
78608     } catch (std::exception& e) {
78609       {
78610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78611       };
78612     } catch (...) {
78613       {
78614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78615       };
78616     }
78617   }
78618 }
78619
78620
78621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78622   void * jresult ;
78623   Dali::Toolkit::ToggleButton result;
78624
78625   {
78626     try {
78627       result = Dali::Toolkit::ToggleButton::New();
78628     } catch (std::out_of_range& e) {
78629       {
78630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78631       };
78632     } catch (std::exception& e) {
78633       {
78634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78635       };
78636     } catch (...) {
78637       {
78638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78639       };
78640     }
78641   }
78642   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78643   return jresult;
78644 }
78645
78646
78647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78648   void * jresult ;
78649   Dali::BaseHandle arg1 ;
78650   Dali::BaseHandle *argp1 ;
78651   Dali::Toolkit::ToggleButton result;
78652
78653   argp1 = (Dali::BaseHandle *)jarg1;
78654   if (!argp1) {
78655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78656     return 0;
78657   }
78658   arg1 = *argp1;
78659   {
78660     try {
78661       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78662     } catch (std::out_of_range& e) {
78663       {
78664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78665       };
78666     } catch (std::exception& e) {
78667       {
78668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78669       };
78670     } catch (...) {
78671       {
78672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78673       };
78674     }
78675   }
78676   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78677   return jresult;
78678 }
78679
78680
78681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78682   void * jresult ;
78683   Dali::Toolkit::Visual::Base *result = 0 ;
78684
78685   {
78686     try {
78687       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78688     } catch (std::out_of_range& e) {
78689       {
78690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78691       };
78692     } catch (std::exception& e) {
78693       {
78694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78695       };
78696     } catch (...) {
78697       {
78698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78699       };
78700     }
78701   }
78702   jresult = (void *)result;
78703   return jresult;
78704 }
78705
78706
78707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78708   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78709
78710   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78711   {
78712     try {
78713       delete arg1;
78714     } catch (std::out_of_range& e) {
78715       {
78716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78717       };
78718     } catch (std::exception& e) {
78719       {
78720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78721       };
78722     } catch (...) {
78723       {
78724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78725       };
78726     }
78727   }
78728 }
78729
78730
78731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78732   void * jresult ;
78733   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78734   Dali::Toolkit::Visual::Base *result = 0 ;
78735
78736   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78737   if (!arg1) {
78738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78739     return 0;
78740   }
78741   {
78742     try {
78743       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78744     } catch (std::out_of_range& e) {
78745       {
78746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78747       };
78748     } catch (std::exception& e) {
78749       {
78750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78751       };
78752     } catch (...) {
78753       {
78754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78755       };
78756     }
78757   }
78758   jresult = (void *)result;
78759   return jresult;
78760 }
78761
78762
78763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78764   void * jresult ;
78765   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78766   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78767   Dali::Toolkit::Visual::Base *result = 0 ;
78768
78769   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78770   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78771   if (!arg2) {
78772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78773     return 0;
78774   }
78775   {
78776     try {
78777       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78778     } catch (std::out_of_range& e) {
78779       {
78780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78781       };
78782     } catch (std::exception& e) {
78783       {
78784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78785       };
78786     } catch (...) {
78787       {
78788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78789       };
78790     }
78791   }
78792   jresult = (void *)result;
78793   return jresult;
78794 }
78795
78796
78797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78798   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78799   std::string *arg2 = 0 ;
78800
78801   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78802   if (!jarg2) {
78803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78804     return ;
78805   }
78806   std::string arg2_str(jarg2);
78807   arg2 = &arg2_str;
78808   {
78809     try {
78810       (arg1)->SetName((std::string const &)*arg2);
78811     } catch (std::out_of_range& e) {
78812       {
78813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78814       };
78815     } catch (std::exception& e) {
78816       {
78817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78818       };
78819     } catch (...) {
78820       {
78821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78822       };
78823     }
78824   }
78825
78826   //argout typemap for const std::string&
78827
78828 }
78829
78830
78831 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78832   char * jresult ;
78833   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78834   std::string *result = 0 ;
78835
78836   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78837   {
78838     try {
78839       result = (std::string *) &(arg1)->GetName();
78840     } catch (std::out_of_range& e) {
78841       {
78842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78843       };
78844     } catch (std::exception& e) {
78845       {
78846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78847       };
78848     } catch (...) {
78849       {
78850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78851       };
78852     }
78853   }
78854   jresult = SWIG_csharp_string_callback(result->c_str());
78855   return jresult;
78856 }
78857
78858
78859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78860   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78861   Dali::Property::Map *arg2 = 0 ;
78862   Dali::Size arg3 ;
78863   Dali::Size *argp3 ;
78864
78865   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78866   arg2 = (Dali::Property::Map *)jarg2;
78867   if (!arg2) {
78868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78869     return ;
78870   }
78871   argp3 = (Dali::Size *)jarg3;
78872   if (!argp3) {
78873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78874     return ;
78875   }
78876   arg3 = *argp3;
78877   {
78878     try {
78879       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78880     } catch (std::out_of_range& e) {
78881       {
78882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78883       };
78884     } catch (std::exception& e) {
78885       {
78886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78887       };
78888     } catch (...) {
78889       {
78890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78891       };
78892     }
78893   }
78894 }
78895
78896
78897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78898   float jresult ;
78899   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78900   float arg2 ;
78901   float result;
78902
78903   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78904   arg2 = (float)jarg2;
78905   {
78906     try {
78907       result = (float)(arg1)->GetHeightForWidth(arg2);
78908     } catch (std::out_of_range& e) {
78909       {
78910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78911       };
78912     } catch (std::exception& e) {
78913       {
78914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78915       };
78916     } catch (...) {
78917       {
78918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78919       };
78920     }
78921   }
78922   jresult = result;
78923   return jresult;
78924 }
78925
78926
78927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78928   float jresult ;
78929   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78930   float arg2 ;
78931   float result;
78932
78933   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78934   arg2 = (float)jarg2;
78935   {
78936     try {
78937       result = (float)(arg1)->GetWidthForHeight(arg2);
78938     } catch (std::out_of_range& e) {
78939       {
78940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78941       };
78942     } catch (std::exception& e) {
78943       {
78944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78945       };
78946     } catch (...) {
78947       {
78948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78949       };
78950     }
78951   }
78952   jresult = result;
78953   return jresult;
78954 }
78955
78956
78957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
78958   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78959   Dali::Vector2 *arg2 = 0 ;
78960
78961   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78962   arg2 = (Dali::Vector2 *)jarg2;
78963   if (!arg2) {
78964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
78965     return ;
78966   }
78967   {
78968     try {
78969       (arg1)->GetNaturalSize(*arg2);
78970     } catch (std::out_of_range& e) {
78971       {
78972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78973       };
78974     } catch (std::exception& e) {
78975       {
78976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78977       };
78978     } catch (...) {
78979       {
78980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78981       };
78982     }
78983   }
78984 }
78985
78986
78987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
78988   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78989   float arg2 ;
78990
78991   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78992   arg2 = (int)jarg2;
78993   {
78994     try {
78995       (arg1)->SetDepthIndex(arg2);
78996     } catch (std::out_of_range& e) {
78997       {
78998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78999       };
79000     } catch (std::exception& e) {
79001       {
79002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79003       };
79004     } catch (...) {
79005       {
79006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79007       };
79008     }
79009   }
79010 }
79011
79012
79013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79014   int jresult ;
79015   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79016   int result;
79017
79018   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79019   {
79020     try {
79021       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79022     } catch (std::out_of_range& e) {
79023       {
79024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79025       };
79026     } catch (std::exception& e) {
79027       {
79028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79029       };
79030     } catch (...) {
79031       {
79032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79033       };
79034     }
79035   }
79036   jresult = result;
79037   return jresult;
79038 }
79039
79040
79041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79042   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79043   Dali::Property::Map *arg2 = 0 ;
79044
79045   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79046   arg2 = (Dali::Property::Map *)jarg2;
79047   if (!arg2) {
79048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79049     return ;
79050   }
79051   {
79052     try {
79053       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79054     } catch (std::out_of_range& e) {
79055       {
79056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79057       };
79058     } catch (std::exception& e) {
79059       {
79060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79061       };
79062     } catch (...) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79065       };
79066     }
79067   }
79068 }
79069
79070
79071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79072   void * jresult ;
79073   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79074   Dali::Toolkit::Visual::Base *result = 0 ;
79075
79076   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79077   {
79078     try {
79079       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79080     } catch (std::out_of_range& e) {
79081       {
79082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79083       };
79084     } catch (std::exception& e) {
79085       {
79086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79087       };
79088     } catch (...) {
79089       {
79090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79091       };
79092     }
79093   }
79094   jresult = (void *)result;
79095   return jresult;
79096 }
79097
79098
79099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79100   void * jresult ;
79101   Dali::Toolkit::VisualFactory result;
79102
79103   {
79104     try {
79105       result = Dali::Toolkit::VisualFactory::Get();
79106     } catch (std::out_of_range& e) {
79107       {
79108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79109       };
79110     } catch (std::exception& e) {
79111       {
79112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79113       };
79114     } catch (...) {
79115       {
79116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79117       };
79118     }
79119   }
79120   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79121   return jresult;
79122 }
79123
79124
79125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79126   void * jresult ;
79127   Dali::Toolkit::VisualFactory *result = 0 ;
79128
79129   {
79130     try {
79131       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79132     } catch (std::out_of_range& e) {
79133       {
79134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79135       };
79136     } catch (std::exception& e) {
79137       {
79138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79139       };
79140     } catch (...) {
79141       {
79142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79143       };
79144     }
79145   }
79146   jresult = (void *)result;
79147   return jresult;
79148 }
79149
79150
79151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79152   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79153
79154   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79155   {
79156     try {
79157       delete arg1;
79158     } catch (std::out_of_range& e) {
79159       {
79160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79161       };
79162     } catch (std::exception& e) {
79163       {
79164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79165       };
79166     } catch (...) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79169       };
79170     }
79171   }
79172 }
79173
79174
79175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79176   void * jresult ;
79177   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79178   Dali::Toolkit::VisualFactory *result = 0 ;
79179
79180   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79181   if (!arg1) {
79182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79183     return 0;
79184   }
79185   {
79186     try {
79187       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79188     } catch (std::out_of_range& e) {
79189       {
79190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79191       };
79192     } catch (std::exception& e) {
79193       {
79194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79195       };
79196     } catch (...) {
79197       {
79198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79199       };
79200     }
79201   }
79202   jresult = (void *)result;
79203   return jresult;
79204 }
79205
79206
79207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79208   void * jresult ;
79209   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79210   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79211   Dali::Toolkit::VisualFactory *result = 0 ;
79212
79213   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79214   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79215   if (!arg2) {
79216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79217     return 0;
79218   }
79219   {
79220     try {
79221       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79222     } catch (std::out_of_range& e) {
79223       {
79224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (std::exception& e) {
79227       {
79228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79229       };
79230     } catch (...) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79233       };
79234     }
79235   }
79236   jresult = (void *)result;
79237   return jresult;
79238 }
79239
79240
79241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79242   void * jresult ;
79243   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79244   Dali::Property::Map *arg2 = 0 ;
79245   Dali::Toolkit::Visual::Base result;
79246
79247   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79248   arg2 = (Dali::Property::Map *)jarg2;
79249   if (!arg2) {
79250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79251     return 0;
79252   }
79253   {
79254     try {
79255       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79256     } catch (std::out_of_range& e) {
79257       {
79258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79259       };
79260     } catch (std::exception& e) {
79261       {
79262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79263       };
79264     } catch (...) {
79265       {
79266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79267       };
79268     }
79269   }
79270   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79271   return jresult;
79272 }
79273
79274
79275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79276   void * jresult ;
79277   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79278   Dali::Image *arg2 = 0 ;
79279   Dali::Toolkit::Visual::Base result;
79280
79281   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79282   arg2 = (Dali::Image *)jarg2;
79283   if (!arg2) {
79284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79285     return 0;
79286   }
79287   {
79288     try {
79289       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (...) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79301       };
79302     }
79303   }
79304   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79305   return jresult;
79306 }
79307
79308
79309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79310   void * jresult ;
79311   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79312   std::string *arg2 = 0 ;
79313   Dali::ImageDimensions arg3 ;
79314   Dali::ImageDimensions *argp3 ;
79315   Dali::Toolkit::Visual::Base result;
79316
79317   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79318   if (!jarg2) {
79319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79320     return 0;
79321   }
79322   std::string arg2_str(jarg2);
79323   arg2 = &arg2_str;
79324   argp3 = (Dali::ImageDimensions *)jarg3;
79325   if (!argp3) {
79326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79327     return 0;
79328   }
79329   arg3 = *argp3;
79330   {
79331     try {
79332       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79340       };
79341     } catch (...) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79344       };
79345     }
79346   }
79347   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79348
79349   //argout typemap for const std::string&
79350
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79356   void * jresult ;
79357   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79358
79359   {
79360     try {
79361       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79362     } catch (std::out_of_range& e) {
79363       {
79364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79365       };
79366     } catch (std::exception& e) {
79367       {
79368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79369       };
79370     } catch (...) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79373       };
79374     }
79375   }
79376   jresult = (void *)result;
79377   return jresult;
79378 }
79379
79380
79381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79382   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79383
79384   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79385   {
79386     try {
79387       delete arg1;
79388     } catch (std::out_of_range& e) {
79389       {
79390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79391       };
79392     } catch (std::exception& e) {
79393       {
79394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79395       };
79396     } catch (...) {
79397       {
79398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79399       };
79400     }
79401   }
79402 }
79403
79404
79405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79406   void * jresult ;
79407   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79408   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79409
79410   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79411   if (!arg1) {
79412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79413     return 0;
79414   }
79415   {
79416     try {
79417       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79418     } catch (std::out_of_range& e) {
79419       {
79420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79421       };
79422     } catch (std::exception& e) {
79423       {
79424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79425       };
79426     } catch (...) {
79427       {
79428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79429       };
79430     }
79431   }
79432   jresult = (void *)result;
79433   return jresult;
79434 }
79435
79436
79437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79438   void * jresult ;
79439   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79440   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79441   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79442
79443   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79444   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79445   if (!arg2) {
79446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79447     return 0;
79448   }
79449   {
79450     try {
79451       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79452     } catch (std::out_of_range& e) {
79453       {
79454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79455       };
79456     } catch (std::exception& e) {
79457       {
79458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79459       };
79460     } catch (...) {
79461       {
79462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79463       };
79464     }
79465   }
79466   jresult = (void *)result;
79467   return jresult;
79468 }
79469
79470
79471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79472   void * jresult ;
79473   Dali::Toolkit::AsyncImageLoader result;
79474
79475   {
79476     try {
79477       result = Dali::Toolkit::AsyncImageLoader::New();
79478     } catch (std::out_of_range& e) {
79479       {
79480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79481       };
79482     } catch (std::exception& e) {
79483       {
79484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79485       };
79486     } catch (...) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79489       };
79490     }
79491   }
79492   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79493   return jresult;
79494 }
79495
79496
79497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79498   void * jresult ;
79499   Dali::BaseHandle arg1 ;
79500   Dali::BaseHandle *argp1 ;
79501   Dali::Toolkit::AsyncImageLoader result;
79502
79503   argp1 = (Dali::BaseHandle *)jarg1;
79504   if (!argp1) {
79505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79506     return 0;
79507   }
79508   arg1 = *argp1;
79509   {
79510     try {
79511       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79512     } catch (std::out_of_range& e) {
79513       {
79514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79515       };
79516     } catch (std::exception& e) {
79517       {
79518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79519       };
79520     } catch (...) {
79521       {
79522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79523       };
79524     }
79525   }
79526   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79527   return jresult;
79528 }
79529
79530
79531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79532   unsigned int jresult ;
79533   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79534   std::string *arg2 = 0 ;
79535   uint32_t result;
79536
79537   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79538   if (!jarg2) {
79539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79540     return 0;
79541   }
79542   std::string arg2_str(jarg2);
79543   arg2 = &arg2_str;
79544   {
79545     try {
79546       result = (arg1)->Load((std::string const &)*arg2);
79547     } catch (std::out_of_range& e) {
79548       {
79549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79550       };
79551     } catch (std::exception& e) {
79552       {
79553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79554       };
79555     } catch (...) {
79556       {
79557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79558       };
79559     }
79560   }
79561   jresult = result;
79562
79563   //argout typemap for const std::string&
79564
79565   return jresult;
79566 }
79567
79568
79569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79570   unsigned int jresult ;
79571   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79572   std::string *arg2 = 0 ;
79573   Dali::ImageDimensions arg3 ;
79574   Dali::ImageDimensions *argp3 ;
79575   uint32_t result;
79576
79577   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79578   if (!jarg2) {
79579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79580     return 0;
79581   }
79582   std::string arg2_str(jarg2);
79583   arg2 = &arg2_str;
79584   argp3 = (Dali::ImageDimensions *)jarg3;
79585   if (!argp3) {
79586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79587     return 0;
79588   }
79589   arg3 = *argp3;
79590   {
79591     try {
79592       result = (arg1)->Load((std::string const &)*arg2,arg3);
79593     } catch (std::out_of_range& e) {
79594       {
79595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79596       };
79597     } catch (std::exception& e) {
79598       {
79599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79604       };
79605     }
79606   }
79607   jresult = result;
79608
79609   //argout typemap for const std::string&
79610
79611   return jresult;
79612 }
79613
79614
79615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79616   unsigned int jresult ;
79617   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79618   std::string *arg2 = 0 ;
79619   Dali::ImageDimensions arg3 ;
79620   Dali::FittingMode::Type arg4 ;
79621   Dali::SamplingMode::Type arg5 ;
79622   bool arg6 ;
79623   Dali::ImageDimensions *argp3 ;
79624   uint32_t result;
79625
79626   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79627   if (!jarg2) {
79628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79629     return 0;
79630   }
79631   std::string arg2_str(jarg2);
79632   arg2 = &arg2_str;
79633   argp3 = (Dali::ImageDimensions *)jarg3;
79634   if (!argp3) {
79635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79636     return 0;
79637   }
79638   arg3 = *argp3;
79639   arg4 = (Dali::FittingMode::Type)jarg4;
79640   arg5 = (Dali::SamplingMode::Type)jarg5;
79641   arg6 = jarg6 ? true : false;
79642   {
79643     try {
79644       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79645     } catch (std::out_of_range& e) {
79646       {
79647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (std::exception& e) {
79650       {
79651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (...) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79656       };
79657     }
79658   }
79659   jresult = result;
79660
79661   //argout typemap for const std::string&
79662
79663   return jresult;
79664 }
79665
79666
79667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79668   unsigned int jresult ;
79669   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79670   uint32_t arg2 ;
79671   bool result;
79672
79673   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79674   arg2 = (uint32_t)jarg2;
79675   {
79676     try {
79677       result = (bool)(arg1)->Cancel(arg2);
79678     } catch (std::out_of_range& e) {
79679       {
79680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79681       };
79682     } catch (std::exception& e) {
79683       {
79684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (...) {
79687       {
79688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79689       };
79690     }
79691   }
79692   jresult = result;
79693   return jresult;
79694 }
79695
79696
79697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79698   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79699
79700   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79701   {
79702     try {
79703       (arg1)->CancelAll();
79704     } catch (std::out_of_range& e) {
79705       {
79706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79707       };
79708     } catch (std::exception& e) {
79709       {
79710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79711       };
79712     } catch (...) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79715       };
79716     }
79717   }
79718 }
79719
79720
79721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79722   void * jresult ;
79723   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79724   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79725
79726   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79727   {
79728     try {
79729       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79730     } catch (std::out_of_range& e) {
79731       {
79732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79733       };
79734     } catch (std::exception& e) {
79735       {
79736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79737       };
79738     } catch (...) {
79739       {
79740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79741       };
79742     }
79743   }
79744   jresult = (void *)result;
79745   return jresult;
79746 }
79747
79748
79749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79750   void * jresult ;
79751   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79752   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79753
79754   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79755   {
79756     try {
79757       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79758     } catch (std::out_of_range& e) {
79759       {
79760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79761       };
79762     } catch (std::exception& e) {
79763       {
79764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79765       };
79766     } catch (...) {
79767       {
79768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79769       };
79770     }
79771   }
79772   jresult = (void *)result;
79773   return jresult;
79774 }
79775
79776
79777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79778   void * jresult ;
79779   std::string *arg1 = 0 ;
79780   Dali::PixelData result;
79781
79782   if (!jarg1) {
79783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79784     return 0;
79785   }
79786   std::string arg1_str(jarg1);
79787   arg1 = &arg1_str;
79788   {
79789     try {
79790       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79791     } catch (std::out_of_range& e) {
79792       {
79793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (std::exception& e) {
79796       {
79797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79802       };
79803     }
79804   }
79805   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79806
79807   //argout typemap for const std::string&
79808
79809   return jresult;
79810 }
79811
79812
79813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79814   void * jresult ;
79815   std::string *arg1 = 0 ;
79816   Dali::ImageDimensions arg2 ;
79817   Dali::ImageDimensions *argp2 ;
79818   Dali::PixelData result;
79819
79820   if (!jarg1) {
79821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79822     return 0;
79823   }
79824   std::string arg1_str(jarg1);
79825   arg1 = &arg1_str;
79826   argp2 = (Dali::ImageDimensions *)jarg2;
79827   if (!argp2) {
79828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79829     return 0;
79830   }
79831   arg2 = *argp2;
79832   {
79833     try {
79834       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79835     } catch (std::out_of_range& e) {
79836       {
79837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79838       };
79839     } catch (std::exception& e) {
79840       {
79841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79842       };
79843     } catch (...) {
79844       {
79845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79846       };
79847     }
79848   }
79849   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79850
79851   //argout typemap for const std::string&
79852
79853   return jresult;
79854 }
79855
79856
79857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79858   void * jresult ;
79859   std::string *arg1 = 0 ;
79860   Dali::ImageDimensions arg2 ;
79861   Dali::FittingMode::Type arg3 ;
79862   Dali::SamplingMode::Type arg4 ;
79863   bool arg5 ;
79864   Dali::ImageDimensions *argp2 ;
79865   Dali::PixelData result;
79866
79867   if (!jarg1) {
79868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79869     return 0;
79870   }
79871   std::string arg1_str(jarg1);
79872   arg1 = &arg1_str;
79873   argp2 = (Dali::ImageDimensions *)jarg2;
79874   if (!argp2) {
79875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79876     return 0;
79877   }
79878   arg2 = *argp2;
79879   arg3 = (Dali::FittingMode::Type)jarg3;
79880   arg4 = (Dali::SamplingMode::Type)jarg4;
79881   arg5 = jarg5 ? true : false;
79882   {
79883     try {
79884       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79885     } catch (std::out_of_range& e) {
79886       {
79887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79888       };
79889     } catch (std::exception& e) {
79890       {
79891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79892       };
79893     } catch (...) {
79894       {
79895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79896       };
79897     }
79898   }
79899   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79900
79901   //argout typemap for const std::string&
79902
79903   return jresult;
79904 }
79905
79906
79907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79908   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79909
79910   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79911   {
79912     try {
79913       delete arg1;
79914     } catch (std::out_of_range& e) {
79915       {
79916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79917       };
79918     } catch (std::exception& e) {
79919       {
79920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79921       };
79922     } catch (...) {
79923       {
79924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79925       };
79926     }
79927   }
79928 }
79929
79930
79931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79932   void * jresult ;
79933   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79934   Dali::Actor arg2 ;
79935   Dali::Actor arg3 ;
79936   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79937   Dali::Actor *argp2 ;
79938   Dali::Actor *argp3 ;
79939   Dali::Actor result;
79940
79941   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79942   argp2 = (Dali::Actor *)jarg2;
79943   if (!argp2) {
79944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79945     return 0;
79946   }
79947   arg2 = *argp2;
79948   argp3 = (Dali::Actor *)jarg3;
79949   if (!argp3) {
79950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79951     return 0;
79952   }
79953   arg3 = *argp3;
79954   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79955   {
79956     try {
79957       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
79958     } catch (std::out_of_range& e) {
79959       {
79960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79961       };
79962     } catch (std::exception& e) {
79963       {
79964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79965       };
79966     } catch (...) {
79967       {
79968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79969       };
79970     }
79971   }
79972   jresult = new Dali::Actor((const Dali::Actor &)result);
79973   return jresult;
79974 }
79975
79976
79977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
79978   void * jresult ;
79979   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
79980
79981   {
79982     try {
79983       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
79984     } catch (std::out_of_range& e) {
79985       {
79986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79987       };
79988     } catch (std::exception& e) {
79989       {
79990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79991       };
79992     } catch (...) {
79993       {
79994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79995       };
79996     }
79997   }
79998   jresult = (void *)result;
79999   return jresult;
80000 }
80001
80002
80003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80004   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80005   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80006   if (director) {
80007     director->swig_connect_director(callback0);
80008   }
80009 }
80010
80011
80012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80013   KeyboardFocusManager arg1 ;
80014   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80015   KeyboardFocusManager *argp1 ;
80016
80017   argp1 = (KeyboardFocusManager *)jarg1;
80018   if (!argp1) {
80019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80020     return ;
80021   }
80022   arg1 = *argp1;
80023   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80024   if (!arg2) {
80025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80026     return ;
80027   }
80028   {
80029     try {
80030       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80031     } catch (std::out_of_range& e) {
80032       {
80033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80034       };
80035     } catch (std::exception& e) {
80036       {
80037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80038       };
80039     } catch (...) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80042       };
80043     }
80044   }
80045 }
80046
80047
80048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80049   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80050
80051   arg1 = (std::vector< unsigned int > *)jarg1;
80052   {
80053     try {
80054       (arg1)->clear();
80055     } catch (std::out_of_range& e) {
80056       {
80057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80058       };
80059     } catch (std::exception& e) {
80060       {
80061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80062       };
80063     } catch (...) {
80064       {
80065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80066       };
80067     }
80068   }
80069 }
80070
80071
80072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80073   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80074   unsigned int *arg2 = 0 ;
80075   unsigned int temp2 ;
80076
80077   arg1 = (std::vector< unsigned int > *)jarg1;
80078   temp2 = (unsigned int)jarg2;
80079   arg2 = &temp2;
80080   {
80081     try {
80082       (arg1)->push_back((unsigned int const &)*arg2);
80083     } catch (std::out_of_range& e) {
80084       {
80085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80086       };
80087     } catch (std::exception& e) {
80088       {
80089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80090       };
80091     } catch (...) {
80092       {
80093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80094       };
80095     }
80096   }
80097 }
80098
80099
80100 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80101   unsigned long jresult ;
80102   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80103   std::vector< unsigned int >::size_type result;
80104
80105   arg1 = (std::vector< unsigned int > *)jarg1;
80106   {
80107     try {
80108       result = ((std::vector< unsigned int > const *)arg1)->size();
80109     } catch (std::out_of_range& e) {
80110       {
80111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (std::exception& e) {
80114       {
80115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (...) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80120       };
80121     }
80122   }
80123   jresult = (unsigned long)result;
80124   return jresult;
80125 }
80126
80127
80128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80129   unsigned long jresult ;
80130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80131   std::vector< unsigned int >::size_type result;
80132
80133   arg1 = (std::vector< unsigned int > *)jarg1;
80134   {
80135     try {
80136       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80144       };
80145     } catch (...) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80148       };
80149     }
80150   }
80151   jresult = (unsigned long)result;
80152   return jresult;
80153 }
80154
80155
80156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80157   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80158   std::vector< unsigned int >::size_type arg2 ;
80159
80160   arg1 = (std::vector< unsigned int > *)jarg1;
80161   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80162   {
80163     try {
80164       (arg1)->reserve(arg2);
80165     } catch (std::out_of_range& e) {
80166       {
80167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80168       };
80169     } catch (std::exception& e) {
80170       {
80171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80172       };
80173     } catch (...) {
80174       {
80175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80176       };
80177     }
80178   }
80179 }
80180
80181
80182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80183   void * jresult ;
80184   std::vector< unsigned int > *result = 0 ;
80185
80186   {
80187     try {
80188       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80189     } catch (std::out_of_range& e) {
80190       {
80191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80192       };
80193     } catch (std::exception& e) {
80194       {
80195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80196       };
80197     } catch (...) {
80198       {
80199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80200       };
80201     }
80202   }
80203   jresult = (void *)result;
80204   return jresult;
80205 }
80206
80207
80208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80209   void * jresult ;
80210   std::vector< unsigned int > *arg1 = 0 ;
80211   std::vector< unsigned int > *result = 0 ;
80212
80213   arg1 = (std::vector< unsigned int > *)jarg1;
80214   if (!arg1) {
80215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80216     return 0;
80217   }
80218   {
80219     try {
80220       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80221     } catch (std::out_of_range& e) {
80222       {
80223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80224       };
80225     } catch (std::exception& e) {
80226       {
80227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80228       };
80229     } catch (...) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80232       };
80233     }
80234   }
80235   jresult = (void *)result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80241   void * jresult ;
80242   int arg1 ;
80243   std::vector< unsigned int > *result = 0 ;
80244
80245   arg1 = (int)jarg1;
80246   {
80247     try {
80248       try {
80249         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80250       }
80251       catch(std::out_of_range &_e) {
80252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80253         return 0;
80254       }
80255
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80276   unsigned int jresult ;
80277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80278   int arg2 ;
80279   unsigned int result;
80280
80281   arg1 = (std::vector< unsigned int > *)jarg1;
80282   arg2 = (int)jarg2;
80283   {
80284     try {
80285       try {
80286         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80287       }
80288       catch(std::out_of_range &_e) {
80289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80290         return 0;
80291       }
80292
80293     } catch (std::out_of_range& e) {
80294       {
80295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80296       };
80297     } catch (std::exception& e) {
80298       {
80299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80304       };
80305     }
80306   }
80307   jresult = result;
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80313   unsigned int jresult ;
80314   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80315   int arg2 ;
80316   unsigned int *result = 0 ;
80317
80318   arg1 = (std::vector< unsigned int > *)jarg1;
80319   arg2 = (int)jarg2;
80320   {
80321     try {
80322       try {
80323         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80324       }
80325       catch(std::out_of_range &_e) {
80326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80327         return 0;
80328       }
80329
80330     } catch (std::out_of_range& e) {
80331       {
80332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80333       };
80334     } catch (std::exception& e) {
80335       {
80336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80337       };
80338     } catch (...) {
80339       {
80340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80341       };
80342     }
80343   }
80344   jresult = *result;
80345   return jresult;
80346 }
80347
80348
80349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80350   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80351   int arg2 ;
80352   unsigned int *arg3 = 0 ;
80353   unsigned int temp3 ;
80354
80355   arg1 = (std::vector< unsigned int > *)jarg1;
80356   arg2 = (int)jarg2;
80357   temp3 = (unsigned int)jarg3;
80358   arg3 = &temp3;
80359   {
80360     try {
80361       try {
80362         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80363       }
80364       catch(std::out_of_range &_e) {
80365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80366         return ;
80367       }
80368
80369     } catch (std::out_of_range& e) {
80370       {
80371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80372       };
80373     } catch (std::exception& e) {
80374       {
80375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80376       };
80377     } catch (...) {
80378       {
80379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80380       };
80381     }
80382   }
80383 }
80384
80385
80386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80387   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80388   std::vector< unsigned int > *arg2 = 0 ;
80389
80390   arg1 = (std::vector< unsigned int > *)jarg1;
80391   arg2 = (std::vector< unsigned int > *)jarg2;
80392   if (!arg2) {
80393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80394     return ;
80395   }
80396   {
80397     try {
80398       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80399     } catch (std::out_of_range& e) {
80400       {
80401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80402       };
80403     } catch (std::exception& e) {
80404       {
80405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80406       };
80407     } catch (...) {
80408       {
80409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80410       };
80411     }
80412   }
80413 }
80414
80415
80416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80417   void * jresult ;
80418   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80419   int arg2 ;
80420   int arg3 ;
80421   std::vector< unsigned int > *result = 0 ;
80422
80423   arg1 = (std::vector< unsigned int > *)jarg1;
80424   arg2 = (int)jarg2;
80425   arg3 = (int)jarg3;
80426   {
80427     try {
80428       try {
80429         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80430       }
80431       catch(std::out_of_range &_e) {
80432         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80433         return 0;
80434       }
80435       catch(std::invalid_argument &_e) {
80436         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80437         return 0;
80438       }
80439
80440     } catch (std::out_of_range& e) {
80441       {
80442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80443       };
80444     } catch (std::exception& e) {
80445       {
80446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (...) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80451       };
80452     }
80453   }
80454   jresult = (void *)result;
80455   return jresult;
80456 }
80457
80458
80459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80460   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80461   int arg2 ;
80462   unsigned int *arg3 = 0 ;
80463   unsigned int temp3 ;
80464
80465   arg1 = (std::vector< unsigned int > *)jarg1;
80466   arg2 = (int)jarg2;
80467   temp3 = (unsigned int)jarg3;
80468   arg3 = &temp3;
80469   {
80470     try {
80471       try {
80472         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80473       }
80474       catch(std::out_of_range &_e) {
80475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80476         return ;
80477       }
80478
80479     } catch (std::out_of_range& e) {
80480       {
80481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80482       };
80483     } catch (std::exception& e) {
80484       {
80485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80486       };
80487     } catch (...) {
80488       {
80489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80490       };
80491     }
80492   }
80493 }
80494
80495
80496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80497   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80498   int arg2 ;
80499   std::vector< unsigned int > *arg3 = 0 ;
80500
80501   arg1 = (std::vector< unsigned int > *)jarg1;
80502   arg2 = (int)jarg2;
80503   arg3 = (std::vector< unsigned int > *)jarg3;
80504   if (!arg3) {
80505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80506     return ;
80507   }
80508   {
80509     try {
80510       try {
80511         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80512       }
80513       catch(std::out_of_range &_e) {
80514         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80515         return ;
80516       }
80517
80518     } catch (std::out_of_range& e) {
80519       {
80520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80521       };
80522     } catch (std::exception& e) {
80523       {
80524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80525       };
80526     } catch (...) {
80527       {
80528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80529       };
80530     }
80531   }
80532 }
80533
80534
80535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80536   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80537   int arg2 ;
80538
80539   arg1 = (std::vector< unsigned int > *)jarg1;
80540   arg2 = (int)jarg2;
80541   {
80542     try {
80543       try {
80544         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80545       }
80546       catch(std::out_of_range &_e) {
80547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80548         return ;
80549       }
80550
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (...) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80562       };
80563     }
80564   }
80565 }
80566
80567
80568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80569   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80570   int arg2 ;
80571   int arg3 ;
80572
80573   arg1 = (std::vector< unsigned int > *)jarg1;
80574   arg2 = (int)jarg2;
80575   arg3 = (int)jarg3;
80576   {
80577     try {
80578       try {
80579         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80580       }
80581       catch(std::out_of_range &_e) {
80582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80583         return ;
80584       }
80585       catch(std::invalid_argument &_e) {
80586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80587         return ;
80588       }
80589
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_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80608   void * jresult ;
80609   unsigned int *arg1 = 0 ;
80610   int arg2 ;
80611   unsigned int temp1 ;
80612   std::vector< unsigned int > *result = 0 ;
80613
80614   temp1 = (unsigned int)jarg1;
80615   arg1 = &temp1;
80616   arg2 = (int)jarg2;
80617   {
80618     try {
80619       try {
80620         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80621       }
80622       catch(std::out_of_range &_e) {
80623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80624         return 0;
80625       }
80626
80627     } catch (std::out_of_range& e) {
80628       {
80629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80630       };
80631     } catch (std::exception& e) {
80632       {
80633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80634       };
80635     } catch (...) {
80636       {
80637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80638       };
80639     }
80640   }
80641   jresult = (void *)result;
80642   return jresult;
80643 }
80644
80645
80646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80647   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80648
80649   arg1 = (std::vector< unsigned int > *)jarg1;
80650   {
80651     try {
80652       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80653     } catch (std::out_of_range& e) {
80654       {
80655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80656       };
80657     } catch (std::exception& e) {
80658       {
80659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80660       };
80661     } catch (...) {
80662       {
80663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80664       };
80665     }
80666   }
80667 }
80668
80669
80670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80671   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80672   int arg2 ;
80673   int arg3 ;
80674
80675   arg1 = (std::vector< unsigned int > *)jarg1;
80676   arg2 = (int)jarg2;
80677   arg3 = (int)jarg3;
80678   {
80679     try {
80680       try {
80681         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80682       }
80683       catch(std::out_of_range &_e) {
80684         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80685         return ;
80686       }
80687       catch(std::invalid_argument &_e) {
80688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80689         return ;
80690       }
80691
80692     } catch (std::out_of_range& e) {
80693       {
80694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80695       };
80696     } catch (std::exception& e) {
80697       {
80698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80699       };
80700     } catch (...) {
80701       {
80702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80703       };
80704     }
80705   }
80706 }
80707
80708
80709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80710   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80711   int arg2 ;
80712   std::vector< unsigned int > *arg3 = 0 ;
80713
80714   arg1 = (std::vector< unsigned int > *)jarg1;
80715   arg2 = (int)jarg2;
80716   arg3 = (std::vector< unsigned int > *)jarg3;
80717   if (!arg3) {
80718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80719     return ;
80720   }
80721   {
80722     try {
80723       try {
80724         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80725       }
80726       catch(std::out_of_range &_e) {
80727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80728         return ;
80729       }
80730
80731     } catch (std::out_of_range& e) {
80732       {
80733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80734       };
80735     } catch (std::exception& e) {
80736       {
80737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80738       };
80739     } catch (...) {
80740       {
80741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80742       };
80743     }
80744   }
80745 }
80746
80747
80748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80749   unsigned int jresult ;
80750   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80751   unsigned int *arg2 = 0 ;
80752   unsigned int temp2 ;
80753   bool result;
80754
80755   arg1 = (std::vector< unsigned int > *)jarg1;
80756   temp2 = (unsigned int)jarg2;
80757   arg2 = &temp2;
80758   {
80759     try {
80760       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80761     } catch (std::out_of_range& e) {
80762       {
80763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80764       };
80765     } catch (std::exception& e) {
80766       {
80767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80768       };
80769     } catch (...) {
80770       {
80771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80772       };
80773     }
80774   }
80775   jresult = result;
80776   return jresult;
80777 }
80778
80779
80780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80781   int jresult ;
80782   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80783   unsigned int *arg2 = 0 ;
80784   unsigned int temp2 ;
80785   int result;
80786
80787   arg1 = (std::vector< unsigned int > *)jarg1;
80788   temp2 = (unsigned int)jarg2;
80789   arg2 = &temp2;
80790   {
80791     try {
80792       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80793     } catch (std::out_of_range& e) {
80794       {
80795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80796       };
80797     } catch (std::exception& e) {
80798       {
80799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (...) {
80802       {
80803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80804       };
80805     }
80806   }
80807   jresult = result;
80808   return jresult;
80809 }
80810
80811
80812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80813   int jresult ;
80814   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80815   unsigned int *arg2 = 0 ;
80816   unsigned int temp2 ;
80817   int result;
80818
80819   arg1 = (std::vector< unsigned int > *)jarg1;
80820   temp2 = (unsigned int)jarg2;
80821   arg2 = &temp2;
80822   {
80823     try {
80824       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80832       };
80833     } catch (...) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80836       };
80837     }
80838   }
80839   jresult = result;
80840   return jresult;
80841 }
80842
80843
80844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80845   unsigned int jresult ;
80846   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80847   unsigned int *arg2 = 0 ;
80848   unsigned int temp2 ;
80849   bool result;
80850
80851   arg1 = (std::vector< unsigned int > *)jarg1;
80852   temp2 = (unsigned int)jarg2;
80853   arg2 = &temp2;
80854   {
80855     try {
80856       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80857     } catch (std::out_of_range& e) {
80858       {
80859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (std::exception& e) {
80862       {
80863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80864       };
80865     } catch (...) {
80866       {
80867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80868       };
80869     }
80870   }
80871   jresult = result;
80872   return jresult;
80873 }
80874
80875
80876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80877   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80878
80879   arg1 = (std::vector< unsigned int > *)jarg1;
80880   {
80881     try {
80882       delete arg1;
80883     } catch (std::out_of_range& e) {
80884       {
80885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80886       };
80887     } catch (std::exception& e) {
80888       {
80889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80894       };
80895     }
80896   }
80897 }
80898
80899
80900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80901   void * jresult ;
80902   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80903
80904   {
80905     try {
80906       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80907     } catch (std::out_of_range& e) {
80908       {
80909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80910       };
80911     } catch (std::exception& e) {
80912       {
80913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80914       };
80915     } catch (...) {
80916       {
80917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80918       };
80919     }
80920   }
80921   jresult = (void *)result;
80922   return jresult;
80923 }
80924
80925
80926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80927   void * jresult ;
80928   unsigned int arg1 ;
80929   Dali::Actor arg2 ;
80930   Dali::Actor *argp2 ;
80931   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80932
80933   arg1 = (unsigned int)jarg1;
80934   argp2 = (Dali::Actor *)jarg2;
80935   if (!argp2) {
80936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80937     return 0;
80938   }
80939   arg2 = *argp2;
80940   {
80941     try {
80942       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80943     } catch (std::out_of_range& e) {
80944       {
80945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (std::exception& e) {
80948       {
80949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (...) {
80952       {
80953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80954       };
80955     }
80956   }
80957   jresult = (void *)result;
80958   return jresult;
80959 }
80960
80961
80962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
80963   void * jresult ;
80964   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
80965   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80966
80967   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80968   if (!arg1) {
80969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
80970     return 0;
80971   }
80972   {
80973     try {
80974       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (...) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80986       };
80987     }
80988   }
80989   jresult = (void *)result;
80990   return jresult;
80991 }
80992
80993
80994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
80995   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
80996   unsigned int arg2 ;
80997
80998   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80999   arg2 = (unsigned int)jarg2;
81000   if (arg1) (arg1)->first = arg2;
81001 }
81002
81003
81004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81005   unsigned int jresult ;
81006   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81007   unsigned int result;
81008
81009   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81010   result = (unsigned int) ((arg1)->first);
81011   jresult = result;
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81017   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81018   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81019
81020   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81021   arg2 = (Dali::Actor *)jarg2;
81022   if (arg1) (arg1)->second = *arg2;
81023 }
81024
81025
81026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81027   void * jresult ;
81028   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81029   Dali::Actor *result = 0 ;
81030
81031   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81032   result = (Dali::Actor *)& ((arg1)->second);
81033   jresult = (void *)result;
81034   return jresult;
81035 }
81036
81037
81038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81039   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81040
81041   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81042   {
81043     try {
81044       delete arg1;
81045     } catch (std::out_of_range& e) {
81046       {
81047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81048       };
81049     } catch (std::exception& e) {
81050       {
81051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81052       };
81053     } catch (...) {
81054       {
81055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81056       };
81057     }
81058   }
81059 }
81060
81061
81062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81063   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81064
81065   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81066   {
81067     try {
81068       (arg1)->clear();
81069     } catch (std::out_of_range& e) {
81070       {
81071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81072       };
81073     } catch (std::exception& e) {
81074       {
81075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81076       };
81077     } catch (...) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81080       };
81081     }
81082   }
81083 }
81084
81085
81086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81087   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81088   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81089
81090   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81091   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81092   if (!arg2) {
81093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81094     return ;
81095   }
81096   {
81097     try {
81098       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81099     } catch (std::out_of_range& e) {
81100       {
81101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81102       };
81103     } catch (std::exception& e) {
81104       {
81105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81106       };
81107     } catch (...) {
81108       {
81109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81110       };
81111     }
81112   }
81113 }
81114
81115
81116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81117   unsigned long jresult ;
81118   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81119   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81120
81121   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81122   {
81123     try {
81124       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81125     } catch (std::out_of_range& e) {
81126       {
81127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81128       };
81129     } catch (std::exception& e) {
81130       {
81131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81132       };
81133     } catch (...) {
81134       {
81135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81136       };
81137     }
81138   }
81139   jresult = (unsigned long)result;
81140   return jresult;
81141 }
81142
81143
81144 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81145   unsigned long jresult ;
81146   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81147   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81148
81149   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81150   {
81151     try {
81152       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81153     } catch (std::out_of_range& e) {
81154       {
81155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (std::exception& e) {
81158       {
81159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167   jresult = (unsigned long)result;
81168   return jresult;
81169 }
81170
81171
81172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81173   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81174   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81175
81176   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81177   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81178   {
81179     try {
81180       (arg1)->reserve(arg2);
81181     } catch (std::out_of_range& e) {
81182       {
81183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81184       };
81185     } catch (std::exception& e) {
81186       {
81187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81188       };
81189     } catch (...) {
81190       {
81191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81192       };
81193     }
81194   }
81195 }
81196
81197
81198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81199   void * jresult ;
81200   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81201
81202   {
81203     try {
81204       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81205     } catch (std::out_of_range& e) {
81206       {
81207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81208       };
81209     } catch (std::exception& e) {
81210       {
81211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81212       };
81213     } catch (...) {
81214       {
81215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81216       };
81217     }
81218   }
81219   jresult = (void *)result;
81220   return jresult;
81221 }
81222
81223
81224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81225   void * jresult ;
81226   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81227   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81228
81229   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81230   if (!arg1) {
81231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81232     return 0;
81233   }
81234   {
81235     try {
81236       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);
81237     } catch (std::out_of_range& e) {
81238       {
81239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81240       };
81241     } catch (std::exception& e) {
81242       {
81243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81244       };
81245     } catch (...) {
81246       {
81247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81248       };
81249     }
81250   }
81251   jresult = (void *)result;
81252   return jresult;
81253 }
81254
81255
81256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81257   void * jresult ;
81258   int arg1 ;
81259   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81260
81261   arg1 = (int)jarg1;
81262   {
81263     try {
81264       try {
81265         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);
81266       }
81267       catch(std::out_of_range &_e) {
81268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81269         return 0;
81270       }
81271
81272     } catch (std::out_of_range& e) {
81273       {
81274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81275       };
81276     } catch (std::exception& e) {
81277       {
81278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (...) {
81281       {
81282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81283       };
81284     }
81285   }
81286   jresult = (void *)result;
81287   return jresult;
81288 }
81289
81290
81291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81292   void * jresult ;
81293   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81294   int arg2 ;
81295   std::pair< unsigned int,Dali::Actor > result;
81296
81297   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81298   arg2 = (int)jarg2;
81299   {
81300     try {
81301       try {
81302         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81303       }
81304       catch(std::out_of_range &_e) {
81305         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81306         return 0;
81307       }
81308
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81320       };
81321     }
81322   }
81323   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81329   void * jresult ;
81330   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81331   int arg2 ;
81332   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81333
81334   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81335   arg2 = (int)jarg2;
81336   {
81337     try {
81338       try {
81339         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81340       }
81341       catch(std::out_of_range &_e) {
81342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81343         return 0;
81344       }
81345
81346     } catch (std::out_of_range& e) {
81347       {
81348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81349       };
81350     } catch (std::exception& e) {
81351       {
81352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81353       };
81354     } catch (...) {
81355       {
81356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81357       };
81358     }
81359   }
81360   jresult = (void *)result;
81361   return jresult;
81362 }
81363
81364
81365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81366   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81367   int arg2 ;
81368   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81369
81370   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81371   arg2 = (int)jarg2;
81372   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81373   if (!arg3) {
81374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81375     return ;
81376   }
81377   {
81378     try {
81379       try {
81380         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);
81381       }
81382       catch(std::out_of_range &_e) {
81383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81384         return ;
81385       }
81386
81387     } catch (std::out_of_range& e) {
81388       {
81389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81390       };
81391     } catch (std::exception& e) {
81392       {
81393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81394       };
81395     } catch (...) {
81396       {
81397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81398       };
81399     }
81400   }
81401 }
81402
81403
81404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81405   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81406   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81407
81408   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81409   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81410   if (!arg2) {
81411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81412     return ;
81413   }
81414   {
81415     try {
81416       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);
81417     } catch (std::out_of_range& e) {
81418       {
81419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81420       };
81421     } catch (std::exception& e) {
81422       {
81423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81424       };
81425     } catch (...) {
81426       {
81427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81428       };
81429     }
81430   }
81431 }
81432
81433
81434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81435   void * jresult ;
81436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81437   int arg2 ;
81438   int arg3 ;
81439   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81440
81441   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81442   arg2 = (int)jarg2;
81443   arg3 = (int)jarg3;
81444   {
81445     try {
81446       try {
81447         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);
81448       }
81449       catch(std::out_of_range &_e) {
81450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81451         return 0;
81452       }
81453       catch(std::invalid_argument &_e) {
81454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81455         return 0;
81456       }
81457
81458     } catch (std::out_of_range& e) {
81459       {
81460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81461       };
81462     } catch (std::exception& e) {
81463       {
81464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81465       };
81466     } catch (...) {
81467       {
81468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81469       };
81470     }
81471   }
81472   jresult = (void *)result;
81473   return jresult;
81474 }
81475
81476
81477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81479   int arg2 ;
81480   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81481
81482   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81483   arg2 = (int)jarg2;
81484   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81485   if (!arg3) {
81486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81487     return ;
81488   }
81489   {
81490     try {
81491       try {
81492         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);
81493       }
81494       catch(std::out_of_range &_e) {
81495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81496         return ;
81497       }
81498
81499     } catch (std::out_of_range& e) {
81500       {
81501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81502       };
81503     } catch (std::exception& e) {
81504       {
81505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81506       };
81507     } catch (...) {
81508       {
81509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81510       };
81511     }
81512   }
81513 }
81514
81515
81516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81517   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81518   int arg2 ;
81519   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81520
81521   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81522   arg2 = (int)jarg2;
81523   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81524   if (!arg3) {
81525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81526     return ;
81527   }
81528   {
81529     try {
81530       try {
81531         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);
81532       }
81533       catch(std::out_of_range &_e) {
81534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81535         return ;
81536       }
81537
81538     } catch (std::out_of_range& e) {
81539       {
81540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81541       };
81542     } catch (std::exception& e) {
81543       {
81544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (...) {
81547       {
81548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81549       };
81550     }
81551   }
81552 }
81553
81554
81555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81556   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81557   int arg2 ;
81558
81559   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81560   arg2 = (int)jarg2;
81561   {
81562     try {
81563       try {
81564         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81565       }
81566       catch(std::out_of_range &_e) {
81567         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81568         return ;
81569       }
81570
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (...) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81582       };
81583     }
81584   }
81585 }
81586
81587
81588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81589   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81590   int arg2 ;
81591   int arg3 ;
81592
81593   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81594   arg2 = (int)jarg2;
81595   arg3 = (int)jarg3;
81596   {
81597     try {
81598       try {
81599         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81600       }
81601       catch(std::out_of_range &_e) {
81602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81603         return ;
81604       }
81605       catch(std::invalid_argument &_e) {
81606         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81607         return ;
81608       }
81609
81610     } catch (std::out_of_range& e) {
81611       {
81612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (std::exception& e) {
81615       {
81616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81621       };
81622     }
81623   }
81624 }
81625
81626
81627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81628   void * jresult ;
81629   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81630   int arg2 ;
81631   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81632
81633   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81634   if (!arg1) {
81635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81636     return 0;
81637   }
81638   arg2 = (int)jarg2;
81639   {
81640     try {
81641       try {
81642         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);
81643       }
81644       catch(std::out_of_range &_e) {
81645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81646         return 0;
81647       }
81648
81649     } catch (std::out_of_range& e) {
81650       {
81651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81652       };
81653     } catch (std::exception& e) {
81654       {
81655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81656       };
81657     } catch (...) {
81658       {
81659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81660       };
81661     }
81662   }
81663   jresult = (void *)result;
81664   return jresult;
81665 }
81666
81667
81668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81669   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81670
81671   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81672   {
81673     try {
81674       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81675     } catch (std::out_of_range& e) {
81676       {
81677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81678       };
81679     } catch (std::exception& e) {
81680       {
81681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81682       };
81683     } catch (...) {
81684       {
81685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81686       };
81687     }
81688   }
81689 }
81690
81691
81692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81693   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81694   int arg2 ;
81695   int arg3 ;
81696
81697   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81698   arg2 = (int)jarg2;
81699   arg3 = (int)jarg3;
81700   {
81701     try {
81702       try {
81703         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81704       }
81705       catch(std::out_of_range &_e) {
81706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81707         return ;
81708       }
81709       catch(std::invalid_argument &_e) {
81710         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81711         return ;
81712       }
81713
81714     } catch (std::out_of_range& e) {
81715       {
81716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81717       };
81718     } catch (std::exception& e) {
81719       {
81720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81725       };
81726     }
81727   }
81728 }
81729
81730
81731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81732   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81733   int arg2 ;
81734   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81735
81736   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81737   arg2 = (int)jarg2;
81738   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81739   if (!arg3) {
81740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81741     return ;
81742   }
81743   {
81744     try {
81745       try {
81746         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);
81747       }
81748       catch(std::out_of_range &_e) {
81749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81750         return ;
81751       }
81752
81753     } catch (std::out_of_range& e) {
81754       {
81755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81756       };
81757     } catch (std::exception& e) {
81758       {
81759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81764       };
81765     }
81766   }
81767 }
81768
81769
81770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81771   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81772
81773   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81774   {
81775     try {
81776       delete arg1;
81777     } catch (std::out_of_range& e) {
81778       {
81779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81780       };
81781     } catch (std::exception& e) {
81782       {
81783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81784       };
81785     } catch (...) {
81786       {
81787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81788       };
81789     }
81790   }
81791 }
81792
81793
81794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81795   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81796
81797   arg1 = (std::vector< Dali::Actor > *)jarg1;
81798   {
81799     try {
81800       (arg1)->clear();
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81812       };
81813     }
81814   }
81815 }
81816
81817
81818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81820   Dali::Actor *arg2 = 0 ;
81821
81822   arg1 = (std::vector< Dali::Actor > *)jarg1;
81823   arg2 = (Dali::Actor *)jarg2;
81824   if (!arg2) {
81825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81826     return ;
81827   }
81828   {
81829     try {
81830       (arg1)->push_back((Dali::Actor const &)*arg2);
81831     } catch (std::out_of_range& e) {
81832       {
81833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81834       };
81835     } catch (std::exception& e) {
81836       {
81837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81838       };
81839     } catch (...) {
81840       {
81841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81842       };
81843     }
81844   }
81845 }
81846
81847
81848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81849   unsigned long jresult ;
81850   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81851   std::vector< Dali::Actor >::size_type result;
81852
81853   arg1 = (std::vector< Dali::Actor > *)jarg1;
81854   {
81855     try {
81856       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81857     } catch (std::out_of_range& e) {
81858       {
81859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81860       };
81861     } catch (std::exception& e) {
81862       {
81863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81864       };
81865     } catch (...) {
81866       {
81867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81868       };
81869     }
81870   }
81871   jresult = (unsigned long)result;
81872   return jresult;
81873 }
81874
81875
81876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81877   unsigned long jresult ;
81878   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81879   std::vector< Dali::Actor >::size_type result;
81880
81881   arg1 = (std::vector< Dali::Actor > *)jarg1;
81882   {
81883     try {
81884       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81885     } catch (std::out_of_range& e) {
81886       {
81887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81888       };
81889     } catch (std::exception& e) {
81890       {
81891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81896       };
81897     }
81898   }
81899   jresult = (unsigned long)result;
81900   return jresult;
81901 }
81902
81903
81904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81905   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81906   std::vector< Dali::Actor >::size_type arg2 ;
81907
81908   arg1 = (std::vector< Dali::Actor > *)jarg1;
81909   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81910   {
81911     try {
81912       (arg1)->reserve(arg2);
81913     } catch (std::out_of_range& e) {
81914       {
81915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81916       };
81917     } catch (std::exception& e) {
81918       {
81919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81920       };
81921     } catch (...) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81924       };
81925     }
81926   }
81927 }
81928
81929
81930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81931   void * jresult ;
81932   std::vector< Dali::Actor > *result = 0 ;
81933
81934   {
81935     try {
81936       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81937     } catch (std::out_of_range& e) {
81938       {
81939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81940       };
81941     } catch (std::exception& e) {
81942       {
81943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81944       };
81945     } catch (...) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81948       };
81949     }
81950   }
81951   jresult = (void *)result;
81952   return jresult;
81953 }
81954
81955
81956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
81957   void * jresult ;
81958   std::vector< Dali::Actor > *arg1 = 0 ;
81959   std::vector< Dali::Actor > *result = 0 ;
81960
81961   arg1 = (std::vector< Dali::Actor > *)jarg1;
81962   if (!arg1) {
81963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
81964     return 0;
81965   }
81966   {
81967     try {
81968       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
81969     } catch (std::out_of_range& e) {
81970       {
81971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81972       };
81973     } catch (std::exception& e) {
81974       {
81975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81976       };
81977     } catch (...) {
81978       {
81979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81980       };
81981     }
81982   }
81983   jresult = (void *)result;
81984   return jresult;
81985 }
81986
81987
81988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
81989   void * jresult ;
81990   int arg1 ;
81991   std::vector< Dali::Actor > *result = 0 ;
81992
81993   arg1 = (int)jarg1;
81994   {
81995     try {
81996       try {
81997         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
81998       }
81999       catch(std::out_of_range &_e) {
82000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82001         return 0;
82002       }
82003
82004     } catch (std::out_of_range& e) {
82005       {
82006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82007       };
82008     } catch (std::exception& e) {
82009       {
82010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82011       };
82012     } catch (...) {
82013       {
82014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82015       };
82016     }
82017   }
82018   jresult = (void *)result;
82019   return jresult;
82020 }
82021
82022
82023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82024   void * jresult ;
82025   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82026   int arg2 ;
82027   Dali::Actor result;
82028
82029   arg1 = (std::vector< Dali::Actor > *)jarg1;
82030   arg2 = (int)jarg2;
82031   {
82032     try {
82033       try {
82034         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82035       }
82036       catch(std::out_of_range &_e) {
82037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82038         return 0;
82039       }
82040
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82052       };
82053     }
82054   }
82055   jresult = new Dali::Actor((const Dali::Actor &)result);
82056   return jresult;
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82061   void * jresult ;
82062   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82063   int arg2 ;
82064   Dali::Actor *result = 0 ;
82065
82066   arg1 = (std::vector< Dali::Actor > *)jarg1;
82067   arg2 = (int)jarg2;
82068   {
82069     try {
82070       try {
82071         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82072       }
82073       catch(std::out_of_range &_e) {
82074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82075         return 0;
82076       }
82077
82078     } catch (std::out_of_range& e) {
82079       {
82080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82081       };
82082     } catch (std::exception& e) {
82083       {
82084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82085       };
82086     } catch (...) {
82087       {
82088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82089       };
82090     }
82091   }
82092   jresult = (void *)result;
82093   return jresult;
82094 }
82095
82096
82097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82098   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82099   int arg2 ;
82100   Dali::Actor *arg3 = 0 ;
82101
82102   arg1 = (std::vector< Dali::Actor > *)jarg1;
82103   arg2 = (int)jarg2;
82104   arg3 = (Dali::Actor *)jarg3;
82105   if (!arg3) {
82106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82107     return ;
82108   }
82109   {
82110     try {
82111       try {
82112         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82113       }
82114       catch(std::out_of_range &_e) {
82115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82116         return ;
82117       }
82118
82119     } catch (std::out_of_range& e) {
82120       {
82121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82122       };
82123     } catch (std::exception& e) {
82124       {
82125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82126       };
82127     } catch (...) {
82128       {
82129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82130       };
82131     }
82132   }
82133 }
82134
82135
82136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82137   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82138   std::vector< Dali::Actor > *arg2 = 0 ;
82139
82140   arg1 = (std::vector< Dali::Actor > *)jarg1;
82141   arg2 = (std::vector< Dali::Actor > *)jarg2;
82142   if (!arg2) {
82143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82144     return ;
82145   }
82146   {
82147     try {
82148       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82149     } catch (std::out_of_range& e) {
82150       {
82151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82152       };
82153     } catch (std::exception& e) {
82154       {
82155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82160       };
82161     }
82162   }
82163 }
82164
82165
82166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82167   void * jresult ;
82168   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82169   int arg2 ;
82170   int arg3 ;
82171   std::vector< Dali::Actor > *result = 0 ;
82172
82173   arg1 = (std::vector< Dali::Actor > *)jarg1;
82174   arg2 = (int)jarg2;
82175   arg3 = (int)jarg3;
82176   {
82177     try {
82178       try {
82179         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82180       }
82181       catch(std::out_of_range &_e) {
82182         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82183         return 0;
82184       }
82185       catch(std::invalid_argument &_e) {
82186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82187         return 0;
82188       }
82189
82190     } catch (std::out_of_range& e) {
82191       {
82192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82193       };
82194     } catch (std::exception& e) {
82195       {
82196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82197       };
82198     } catch (...) {
82199       {
82200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82201       };
82202     }
82203   }
82204   jresult = (void *)result;
82205   return jresult;
82206 }
82207
82208
82209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82210   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82211   int arg2 ;
82212   Dali::Actor *arg3 = 0 ;
82213
82214   arg1 = (std::vector< Dali::Actor > *)jarg1;
82215   arg2 = (int)jarg2;
82216   arg3 = (Dali::Actor *)jarg3;
82217   if (!arg3) {
82218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82219     return ;
82220   }
82221   {
82222     try {
82223       try {
82224         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82225       }
82226       catch(std::out_of_range &_e) {
82227         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82228         return ;
82229       }
82230
82231     } catch (std::out_of_range& e) {
82232       {
82233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82234       };
82235     } catch (std::exception& e) {
82236       {
82237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82238       };
82239     } catch (...) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82242       };
82243     }
82244   }
82245 }
82246
82247
82248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82249   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82250   int arg2 ;
82251   std::vector< Dali::Actor > *arg3 = 0 ;
82252
82253   arg1 = (std::vector< Dali::Actor > *)jarg1;
82254   arg2 = (int)jarg2;
82255   arg3 = (std::vector< Dali::Actor > *)jarg3;
82256   if (!arg3) {
82257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82258     return ;
82259   }
82260   {
82261     try {
82262       try {
82263         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82264       }
82265       catch(std::out_of_range &_e) {
82266         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82267         return ;
82268       }
82269
82270     } catch (std::out_of_range& e) {
82271       {
82272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82273       };
82274     } catch (std::exception& e) {
82275       {
82276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82277       };
82278     } catch (...) {
82279       {
82280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82281       };
82282     }
82283   }
82284 }
82285
82286
82287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82288   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82289   int arg2 ;
82290
82291   arg1 = (std::vector< Dali::Actor > *)jarg1;
82292   arg2 = (int)jarg2;
82293   {
82294     try {
82295       try {
82296         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82297       }
82298       catch(std::out_of_range &_e) {
82299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82300         return ;
82301       }
82302
82303     } catch (std::out_of_range& e) {
82304       {
82305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (std::exception& e) {
82308       {
82309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82310       };
82311     } catch (...) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82314       };
82315     }
82316   }
82317 }
82318
82319
82320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82321   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82322   int arg2 ;
82323   int arg3 ;
82324
82325   arg1 = (std::vector< Dali::Actor > *)jarg1;
82326   arg2 = (int)jarg2;
82327   arg3 = (int)jarg3;
82328   {
82329     try {
82330       try {
82331         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82332       }
82333       catch(std::out_of_range &_e) {
82334         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82335         return ;
82336       }
82337       catch(std::invalid_argument &_e) {
82338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82339         return ;
82340       }
82341
82342     } catch (std::out_of_range& e) {
82343       {
82344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82345       };
82346     } catch (std::exception& e) {
82347       {
82348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82349       };
82350     } catch (...) {
82351       {
82352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82353       };
82354     }
82355   }
82356 }
82357
82358
82359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82360   void * jresult ;
82361   Dali::Actor *arg1 = 0 ;
82362   int arg2 ;
82363   std::vector< Dali::Actor > *result = 0 ;
82364
82365   arg1 = (Dali::Actor *)jarg1;
82366   if (!arg1) {
82367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82368     return 0;
82369   }
82370   arg2 = (int)jarg2;
82371   {
82372     try {
82373       try {
82374         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82375       }
82376       catch(std::out_of_range &_e) {
82377         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82378         return 0;
82379       }
82380
82381     } catch (std::out_of_range& e) {
82382       {
82383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82384       };
82385     } catch (std::exception& e) {
82386       {
82387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82388       };
82389     } catch (...) {
82390       {
82391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82392       };
82393     }
82394   }
82395   jresult = (void *)result;
82396   return jresult;
82397 }
82398
82399
82400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82401   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82402
82403   arg1 = (std::vector< Dali::Actor > *)jarg1;
82404   {
82405     try {
82406       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82407     } catch (std::out_of_range& e) {
82408       {
82409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82410       };
82411     } catch (std::exception& e) {
82412       {
82413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82414       };
82415     } catch (...) {
82416       {
82417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82418       };
82419     }
82420   }
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82426   int arg2 ;
82427   int arg3 ;
82428
82429   arg1 = (std::vector< Dali::Actor > *)jarg1;
82430   arg2 = (int)jarg2;
82431   arg3 = (int)jarg3;
82432   {
82433     try {
82434       try {
82435         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82436       }
82437       catch(std::out_of_range &_e) {
82438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82439         return ;
82440       }
82441       catch(std::invalid_argument &_e) {
82442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82443         return ;
82444       }
82445
82446     } catch (std::out_of_range& e) {
82447       {
82448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82449       };
82450     } catch (std::exception& e) {
82451       {
82452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82453       };
82454     } catch (...) {
82455       {
82456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82457       };
82458     }
82459   }
82460 }
82461
82462
82463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82464   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82465   int arg2 ;
82466   std::vector< Dali::Actor > *arg3 = 0 ;
82467
82468   arg1 = (std::vector< Dali::Actor > *)jarg1;
82469   arg2 = (int)jarg2;
82470   arg3 = (std::vector< Dali::Actor > *)jarg3;
82471   if (!arg3) {
82472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82473     return ;
82474   }
82475   {
82476     try {
82477       try {
82478         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82479       }
82480       catch(std::out_of_range &_e) {
82481         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82482         return ;
82483       }
82484
82485     } catch (std::out_of_range& e) {
82486       {
82487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82488       };
82489     } catch (std::exception& e) {
82490       {
82491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82492       };
82493     } catch (...) {
82494       {
82495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82496       };
82497     }
82498   }
82499 }
82500
82501
82502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82503   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82504
82505   arg1 = (std::vector< Dali::Actor > *)jarg1;
82506   {
82507     try {
82508       delete arg1;
82509     } catch (std::out_of_range& e) {
82510       {
82511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82512       };
82513     } catch (std::exception& e) {
82514       {
82515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82516       };
82517     } catch (...) {
82518       {
82519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82520       };
82521     }
82522   }
82523 }
82524
82525
82526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82527   unsigned int jresult ;
82528   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82529   bool result;
82530
82531   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82532   {
82533     try {
82534       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82535     } catch (std::out_of_range& e) {
82536       {
82537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82538       };
82539     } catch (std::exception& e) {
82540       {
82541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82542       };
82543     } catch (...) {
82544       {
82545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82546       };
82547     }
82548   }
82549   jresult = result;
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82555   unsigned long jresult ;
82556   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82557   std::size_t result;
82558
82559   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82560   {
82561     try {
82562       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82563     } catch (std::out_of_range& e) {
82564       {
82565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82566       };
82567     } catch (std::exception& e) {
82568       {
82569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82570       };
82571     } catch (...) {
82572       {
82573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82574       };
82575     }
82576   }
82577   jresult = (unsigned long)result;
82578   return jresult;
82579 }
82580
82581
82582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82583   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82584   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82585
82586   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82587   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82588   {
82589     try {
82590       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82591     } catch (std::out_of_range& e) {
82592       {
82593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82594       };
82595     } catch (std::exception& e) {
82596       {
82597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82598       };
82599     } catch (...) {
82600       {
82601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82602       };
82603     }
82604   }
82605 }
82606
82607
82608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82609   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82610   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82611
82612   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82613   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82614   {
82615     try {
82616       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82617     } catch (std::out_of_range& e) {
82618       {
82619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82620       };
82621     } catch (std::exception& e) {
82622       {
82623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82624       };
82625     } catch (...) {
82626       {
82627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82628       };
82629     }
82630   }
82631 }
82632
82633
82634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82635   unsigned int jresult ;
82636   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82637   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82638   bool result;
82639
82640   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82641   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82642   if (!arg2) {
82643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82644     return 0;
82645   }
82646   {
82647     try {
82648       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (...) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82660       };
82661     }
82662   }
82663   jresult = result;
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82669   void * jresult ;
82670   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82671
82672   {
82673     try {
82674       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82675     } catch (std::out_of_range& e) {
82676       {
82677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82678       };
82679     } catch (std::exception& e) {
82680       {
82681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82682       };
82683     } catch (...) {
82684       {
82685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82686       };
82687     }
82688   }
82689   jresult = (void *)result;
82690   return jresult;
82691 }
82692
82693
82694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82695   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82696
82697   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82698   {
82699     try {
82700       delete arg1;
82701     } catch (std::out_of_range& e) {
82702       {
82703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82704       };
82705     } catch (std::exception& e) {
82706       {
82707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82708       };
82709     } catch (...) {
82710       {
82711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82712       };
82713     }
82714   }
82715 }
82716
82717
82718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82719   unsigned int jresult ;
82720   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82721   bool result;
82722
82723   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82724   {
82725     try {
82726       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);
82727     } catch (std::out_of_range& e) {
82728       {
82729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82730       };
82731     } catch (std::exception& e) {
82732       {
82733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82734       };
82735     } catch (...) {
82736       {
82737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82738       };
82739     }
82740   }
82741   jresult = result;
82742   return jresult;
82743 }
82744
82745
82746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82747   unsigned long jresult ;
82748   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82749   std::size_t result;
82750
82751   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82752   {
82753     try {
82754       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);
82755     } catch (std::out_of_range& e) {
82756       {
82757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82758       };
82759     } catch (std::exception& e) {
82760       {
82761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82762       };
82763     } catch (...) {
82764       {
82765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82766       };
82767     }
82768   }
82769   jresult = (unsigned long)result;
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82775   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82776   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82777
82778   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82779   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82780   {
82781     try {
82782       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82783     } catch (std::out_of_range& e) {
82784       {
82785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82786       };
82787     } catch (std::exception& e) {
82788       {
82789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82790       };
82791     } catch (...) {
82792       {
82793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82794       };
82795     }
82796   }
82797 }
82798
82799
82800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82801   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82802   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82803
82804   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82805   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82806   {
82807     try {
82808       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82809     } catch (std::out_of_range& e) {
82810       {
82811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82812       };
82813     } catch (std::exception& e) {
82814       {
82815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82816       };
82817     } catch (...) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82820       };
82821     }
82822   }
82823 }
82824
82825
82826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82827   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82828   Dali::Actor arg2 ;
82829   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82830   Dali::Actor *argp2 ;
82831
82832   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82833   argp2 = (Dali::Actor *)jarg2;
82834   if (!argp2) {
82835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82836     return ;
82837   }
82838   arg2 = *argp2;
82839   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82840   {
82841     try {
82842       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82843     } catch (std::out_of_range& e) {
82844       {
82845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82846       };
82847     } catch (std::exception& e) {
82848       {
82849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82850       };
82851     } catch (...) {
82852       {
82853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82854       };
82855     }
82856   }
82857 }
82858
82859
82860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82861   void * jresult ;
82862   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82863
82864   {
82865     try {
82866       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82867     } catch (std::out_of_range& e) {
82868       {
82869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82870       };
82871     } catch (std::exception& e) {
82872       {
82873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82874       };
82875     } catch (...) {
82876       {
82877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82878       };
82879     }
82880   }
82881   jresult = (void *)result;
82882   return jresult;
82883 }
82884
82885
82886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82887   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82888
82889   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82890   {
82891     try {
82892       delete arg1;
82893     } catch (std::out_of_range& e) {
82894       {
82895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82896       };
82897     } catch (std::exception& e) {
82898       {
82899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82900       };
82901     } catch (...) {
82902       {
82903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82904       };
82905     }
82906   }
82907 }
82908
82909
82910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82911   unsigned int jresult ;
82912   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82913   bool result;
82914
82915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82916   {
82917     try {
82918       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82919     } catch (std::out_of_range& e) {
82920       {
82921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82922       };
82923     } catch (std::exception& e) {
82924       {
82925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82926       };
82927     } catch (...) {
82928       {
82929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82930       };
82931     }
82932   }
82933   jresult = result;
82934   return jresult;
82935 }
82936
82937
82938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82939   unsigned long jresult ;
82940   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82941   std::size_t result;
82942
82943   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82944   {
82945     try {
82946       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82947     } catch (std::out_of_range& e) {
82948       {
82949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82950       };
82951     } catch (std::exception& e) {
82952       {
82953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82954       };
82955     } catch (...) {
82956       {
82957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82958       };
82959     }
82960   }
82961   jresult = (unsigned long)result;
82962   return jresult;
82963 }
82964
82965
82966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
82967   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82968   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82969
82970   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82971   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82972   {
82973     try {
82974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
82975     } catch (std::out_of_range& e) {
82976       {
82977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82978       };
82979     } catch (std::exception& e) {
82980       {
82981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82986       };
82987     }
82988   }
82989 }
82990
82991
82992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
82993   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82994   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82995
82996   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82997   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82998   {
82999     try {
83000       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83001     } catch (std::out_of_range& e) {
83002       {
83003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83004       };
83005     } catch (std::exception& e) {
83006       {
83007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83008       };
83009     } catch (...) {
83010       {
83011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83012       };
83013     }
83014   }
83015 }
83016
83017
83018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83019   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83020   Dali::Actor arg2 ;
83021   Dali::Actor arg3 ;
83022   Dali::Actor *argp2 ;
83023   Dali::Actor *argp3 ;
83024
83025   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83026   argp2 = (Dali::Actor *)jarg2;
83027   if (!argp2) {
83028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83029     return ;
83030   }
83031   arg2 = *argp2;
83032   argp3 = (Dali::Actor *)jarg3;
83033   if (!argp3) {
83034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83035     return ;
83036   }
83037   arg3 = *argp3;
83038   {
83039     try {
83040       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83041     } catch (std::out_of_range& e) {
83042       {
83043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83044       };
83045     } catch (std::exception& e) {
83046       {
83047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83048       };
83049     } catch (...) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83052       };
83053     }
83054   }
83055 }
83056
83057
83058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83059   void * jresult ;
83060   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83061
83062   {
83063     try {
83064       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83065     } catch (std::out_of_range& e) {
83066       {
83067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83068       };
83069     } catch (std::exception& e) {
83070       {
83071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83072       };
83073     } catch (...) {
83074       {
83075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83076       };
83077     }
83078   }
83079   jresult = (void *)result;
83080   return jresult;
83081 }
83082
83083
83084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83085   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83086
83087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83088   {
83089     try {
83090       delete arg1;
83091     } catch (std::out_of_range& e) {
83092       {
83093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83094       };
83095     } catch (std::exception& e) {
83096       {
83097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83098       };
83099     } catch (...) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83102       };
83103     }
83104   }
83105 }
83106
83107
83108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83109   unsigned int jresult ;
83110   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83111   bool result;
83112
83113   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83114   {
83115     try {
83116       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83117     } catch (std::out_of_range& e) {
83118       {
83119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83120       };
83121     } catch (std::exception& e) {
83122       {
83123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83124       };
83125     } catch (...) {
83126       {
83127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83128       };
83129     }
83130   }
83131   jresult = result;
83132   return jresult;
83133 }
83134
83135
83136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83137   unsigned long jresult ;
83138   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83139   std::size_t result;
83140
83141   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83142   {
83143     try {
83144       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83145     } catch (std::out_of_range& e) {
83146       {
83147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83148       };
83149     } catch (std::exception& e) {
83150       {
83151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83152       };
83153     } catch (...) {
83154       {
83155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83156       };
83157     }
83158   }
83159   jresult = (unsigned long)result;
83160   return jresult;
83161 }
83162
83163
83164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83165   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83166   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83167
83168   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83169   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83170   {
83171     try {
83172       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83173     } catch (std::out_of_range& e) {
83174       {
83175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83176       };
83177     } catch (std::exception& e) {
83178       {
83179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83184       };
83185     }
83186   }
83187 }
83188
83189
83190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83191   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83192   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83193
83194   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83195   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83196   {
83197     try {
83198       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83199     } catch (std::out_of_range& e) {
83200       {
83201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (std::exception& e) {
83204       {
83205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83206       };
83207     } catch (...) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83210       };
83211     }
83212   }
83213 }
83214
83215
83216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83217   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83218   Dali::Actor arg2 ;
83219   bool arg3 ;
83220   Dali::Actor *argp2 ;
83221
83222   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83223   argp2 = (Dali::Actor *)jarg2;
83224   if (!argp2) {
83225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83226     return ;
83227   }
83228   arg2 = *argp2;
83229   arg3 = jarg3 ? true : false;
83230   {
83231     try {
83232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83233     } catch (std::out_of_range& e) {
83234       {
83235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83236       };
83237     } catch (std::exception& e) {
83238       {
83239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83240       };
83241     } catch (...) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83244       };
83245     }
83246   }
83247 }
83248
83249
83250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83251   void * jresult ;
83252   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83253
83254   {
83255     try {
83256       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83257     } catch (std::out_of_range& e) {
83258       {
83259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83260       };
83261     } catch (std::exception& e) {
83262       {
83263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83264       };
83265     } catch (...) {
83266       {
83267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83268       };
83269     }
83270   }
83271   jresult = (void *)result;
83272   return jresult;
83273 }
83274
83275
83276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83277   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83278
83279   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83280   {
83281     try {
83282       delete arg1;
83283     } catch (std::out_of_range& e) {
83284       {
83285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83286       };
83287     } catch (std::exception& e) {
83288       {
83289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83290       };
83291     } catch (...) {
83292       {
83293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83294       };
83295     }
83296   }
83297 }
83298
83299
83300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83301   unsigned int jresult ;
83302   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83303   bool result;
83304
83305   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83306   {
83307     try {
83308       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);
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (...) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83320       };
83321     }
83322   }
83323   jresult = result;
83324   return jresult;
83325 }
83326
83327
83328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83329   unsigned long jresult ;
83330   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83331   std::size_t result;
83332
83333   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83334   {
83335     try {
83336       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);
83337     } catch (std::out_of_range& e) {
83338       {
83339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (std::exception& e) {
83342       {
83343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83348       };
83349     }
83350   }
83351   jresult = (unsigned long)result;
83352   return jresult;
83353 }
83354
83355
83356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83357   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83358   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83359
83360   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83361   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83362   {
83363     try {
83364       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83365     } catch (std::out_of_range& e) {
83366       {
83367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83368       };
83369     } catch (std::exception& e) {
83370       {
83371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83372       };
83373     } catch (...) {
83374       {
83375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83376       };
83377     }
83378   }
83379 }
83380
83381
83382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83383   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83384   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83385
83386   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83387   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83388   {
83389     try {
83390       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83391     } catch (std::out_of_range& e) {
83392       {
83393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83394       };
83395     } catch (std::exception& e) {
83396       {
83397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83398       };
83399     } catch (...) {
83400       {
83401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83402       };
83403     }
83404   }
83405 }
83406
83407
83408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83409   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83410   Dali::Toolkit::StyleManager arg2 ;
83411   Dali::StyleChange::Type arg3 ;
83412   Dali::Toolkit::StyleManager *argp2 ;
83413
83414   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83415   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83416   if (!argp2) {
83417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83418     return ;
83419   }
83420   arg2 = *argp2;
83421   arg3 = (Dali::StyleChange::Type)jarg3;
83422   {
83423     try {
83424       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83425     } catch (std::out_of_range& e) {
83426       {
83427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83428       };
83429     } catch (std::exception& e) {
83430       {
83431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83432       };
83433     } catch (...) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83436       };
83437     }
83438   }
83439 }
83440
83441
83442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83443   void * jresult ;
83444   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83445
83446   {
83447     try {
83448       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83449     } catch (std::out_of_range& e) {
83450       {
83451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (std::exception& e) {
83454       {
83455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83460       };
83461     }
83462   }
83463   jresult = (void *)result;
83464   return jresult;
83465 }
83466
83467
83468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83469   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83470
83471   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83472   {
83473     try {
83474       delete arg1;
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83482       };
83483     } catch (...) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83486       };
83487     }
83488   }
83489 }
83490
83491
83492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83493   unsigned int jresult ;
83494   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83495   bool result;
83496
83497   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83498   {
83499     try {
83500       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83508       };
83509     } catch (...) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83512       };
83513     }
83514   }
83515   jresult = result;
83516   return jresult;
83517 }
83518
83519
83520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83521   unsigned long jresult ;
83522   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83523   std::size_t result;
83524
83525   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83526   {
83527     try {
83528       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83529     } catch (std::out_of_range& e) {
83530       {
83531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (std::exception& e) {
83534       {
83535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (...) {
83538       {
83539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83540       };
83541     }
83542   }
83543   jresult = (unsigned long)result;
83544   return jresult;
83545 }
83546
83547
83548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83549   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83550   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83551
83552   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83553   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83554   {
83555     try {
83556       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83557     } catch (std::out_of_range& e) {
83558       {
83559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83560       };
83561     } catch (std::exception& e) {
83562       {
83563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83564       };
83565     } catch (...) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83568       };
83569     }
83570   }
83571 }
83572
83573
83574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83575   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83576   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83577
83578   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83579   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83580   {
83581     try {
83582       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83583     } catch (std::out_of_range& e) {
83584       {
83585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83586       };
83587     } catch (std::exception& e) {
83588       {
83589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83590       };
83591     } catch (...) {
83592       {
83593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83594       };
83595     }
83596   }
83597 }
83598
83599
83600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83601   unsigned int jresult ;
83602   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83603   Dali::Toolkit::Button arg2 ;
83604   Dali::Toolkit::Button *argp2 ;
83605   bool result;
83606
83607   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83608   argp2 = (Dali::Toolkit::Button *)jarg2;
83609   if (!argp2) {
83610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83611     return 0;
83612   }
83613   arg2 = *argp2;
83614   {
83615     try {
83616       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83617     } catch (std::out_of_range& e) {
83618       {
83619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83620       };
83621     } catch (std::exception& e) {
83622       {
83623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (...) {
83626       {
83627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83628       };
83629     }
83630   }
83631   jresult = result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83637   void * jresult ;
83638   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83639
83640   {
83641     try {
83642       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83643     } catch (std::out_of_range& e) {
83644       {
83645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83646       };
83647     } catch (std::exception& e) {
83648       {
83649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83654       };
83655     }
83656   }
83657   jresult = (void *)result;
83658   return jresult;
83659 }
83660
83661
83662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83663   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83664
83665   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83666   {
83667     try {
83668       delete arg1;
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83676       };
83677     } catch (...) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83680       };
83681     }
83682   }
83683 }
83684
83685
83686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83687   unsigned int jresult ;
83688   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83689   bool result;
83690
83691   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83692   {
83693     try {
83694       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83695     } catch (std::out_of_range& e) {
83696       {
83697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83698       };
83699     } catch (std::exception& e) {
83700       {
83701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (...) {
83704       {
83705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83706       };
83707     }
83708   }
83709   jresult = result;
83710   return jresult;
83711 }
83712
83713
83714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83715   unsigned long jresult ;
83716   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83717   std::size_t result;
83718
83719   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83720   {
83721     try {
83722       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83723     } catch (std::out_of_range& e) {
83724       {
83725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83726       };
83727     } catch (std::exception& e) {
83728       {
83729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83730       };
83731     } catch (...) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83734       };
83735     }
83736   }
83737   jresult = (unsigned long)result;
83738   return jresult;
83739 }
83740
83741
83742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83743   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83744   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83745
83746   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83747   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83748   {
83749     try {
83750       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83751     } catch (std::out_of_range& e) {
83752       {
83753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83754       };
83755     } catch (std::exception& e) {
83756       {
83757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83758       };
83759     } catch (...) {
83760       {
83761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83762       };
83763     }
83764   }
83765 }
83766
83767
83768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83769   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83770   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83771
83772   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83773   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83774   {
83775     try {
83776       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83777     } catch (std::out_of_range& e) {
83778       {
83779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83780       };
83781     } catch (std::exception& e) {
83782       {
83783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83784       };
83785     } catch (...) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83788       };
83789     }
83790   }
83791 }
83792
83793
83794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83795   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83796   Dali::Toolkit::GaussianBlurView arg2 ;
83797   Dali::Toolkit::GaussianBlurView *argp2 ;
83798
83799   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83800   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83801   if (!argp2) {
83802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83803     return ;
83804   }
83805   arg2 = *argp2;
83806   {
83807     try {
83808       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83809     } catch (std::out_of_range& e) {
83810       {
83811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83812       };
83813     } catch (std::exception& e) {
83814       {
83815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83816       };
83817     } catch (...) {
83818       {
83819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83820       };
83821     }
83822   }
83823 }
83824
83825
83826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83827   void * jresult ;
83828   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83829
83830   {
83831     try {
83832       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83844       };
83845     }
83846   }
83847   jresult = (void *)result;
83848   return jresult;
83849 }
83850
83851
83852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83853   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83854
83855   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83856   {
83857     try {
83858       delete arg1;
83859     } catch (std::out_of_range& e) {
83860       {
83861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83862       };
83863     } catch (std::exception& e) {
83864       {
83865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83866       };
83867     } catch (...) {
83868       {
83869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83870       };
83871     }
83872   }
83873 }
83874
83875
83876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83877   unsigned int jresult ;
83878   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83879   bool result;
83880
83881   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83882   {
83883     try {
83884       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);
83885     } catch (std::out_of_range& e) {
83886       {
83887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83888       };
83889     } catch (std::exception& e) {
83890       {
83891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83892       };
83893     } catch (...) {
83894       {
83895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83896       };
83897     }
83898   }
83899   jresult = result;
83900   return jresult;
83901 }
83902
83903
83904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83905   unsigned long jresult ;
83906   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83907   std::size_t result;
83908
83909   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83910   {
83911     try {
83912       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);
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (...) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83924       };
83925     }
83926   }
83927   jresult = (unsigned long)result;
83928   return jresult;
83929 }
83930
83931
83932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83933   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83934   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83935
83936   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83937   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83938   {
83939     try {
83940       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (...) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83952       };
83953     }
83954   }
83955 }
83956
83957
83958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
83959   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83960   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83961
83962   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83963   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83964   {
83965     try {
83966       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83967     } catch (std::out_of_range& e) {
83968       {
83969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83970       };
83971     } catch (std::exception& e) {
83972       {
83973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83974       };
83975     } catch (...) {
83976       {
83977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83978       };
83979     }
83980   }
83981 }
83982
83983
83984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
83985   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83986   Dali::Toolkit::PageTurnView arg2 ;
83987   unsigned int arg3 ;
83988   bool arg4 ;
83989   Dali::Toolkit::PageTurnView *argp2 ;
83990
83991   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83992   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
83993   if (!argp2) {
83994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
83995     return ;
83996   }
83997   arg2 = *argp2;
83998   arg3 = (unsigned int)jarg3;
83999   arg4 = jarg4 ? true : false;
84000   {
84001     try {
84002       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84003     } catch (std::out_of_range& e) {
84004       {
84005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84006       };
84007     } catch (std::exception& e) {
84008       {
84009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84010       };
84011     } catch (...) {
84012       {
84013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84014       };
84015     }
84016   }
84017 }
84018
84019
84020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84021   void * jresult ;
84022   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84023
84024   {
84025     try {
84026       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84027     } catch (std::out_of_range& e) {
84028       {
84029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84030       };
84031     } catch (std::exception& e) {
84032       {
84033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84034       };
84035     } catch (...) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84038       };
84039     }
84040   }
84041   jresult = (void *)result;
84042   return jresult;
84043 }
84044
84045
84046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84047   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84048
84049   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84050   {
84051     try {
84052       delete arg1;
84053     } catch (std::out_of_range& e) {
84054       {
84055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (std::exception& e) {
84058       {
84059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84064       };
84065     }
84066   }
84067 }
84068
84069
84070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84071   unsigned int jresult ;
84072   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84073   bool result;
84074
84075   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84076   {
84077     try {
84078       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84086       };
84087     } catch (...) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84090       };
84091     }
84092   }
84093   jresult = result;
84094   return jresult;
84095 }
84096
84097
84098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84099   unsigned long jresult ;
84100   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84101   std::size_t result;
84102
84103   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84104   {
84105     try {
84106       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84107     } catch (std::out_of_range& e) {
84108       {
84109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84110       };
84111     } catch (std::exception& e) {
84112       {
84113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84114       };
84115     } catch (...) {
84116       {
84117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84118       };
84119     }
84120   }
84121   jresult = (unsigned long)result;
84122   return jresult;
84123 }
84124
84125
84126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84127   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84128   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84129
84130   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84131   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84132   {
84133     try {
84134       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84135     } catch (std::out_of_range& e) {
84136       {
84137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (std::exception& e) {
84140       {
84141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84146       };
84147     }
84148   }
84149 }
84150
84151
84152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84153   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84154   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84155
84156   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84157   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84158   {
84159     try {
84160       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84161     } catch (std::out_of_range& e) {
84162       {
84163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84164       };
84165     } catch (std::exception& e) {
84166       {
84167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84168       };
84169     } catch (...) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84172       };
84173     }
84174   }
84175 }
84176
84177
84178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84179   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84180   Dali::Toolkit::PageTurnView arg2 ;
84181   Dali::Toolkit::PageTurnView *argp2 ;
84182
84183   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84184   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84185   if (!argp2) {
84186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84187     return ;
84188   }
84189   arg2 = *argp2;
84190   {
84191     try {
84192       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84193     } catch (std::out_of_range& e) {
84194       {
84195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84196       };
84197     } catch (std::exception& e) {
84198       {
84199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84200       };
84201     } catch (...) {
84202       {
84203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84204       };
84205     }
84206   }
84207 }
84208
84209
84210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84211   void * jresult ;
84212   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84213
84214   {
84215     try {
84216       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84228       };
84229     }
84230   }
84231   jresult = (void *)result;
84232   return jresult;
84233 }
84234
84235
84236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84237   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84238
84239   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84240   {
84241     try {
84242       delete arg1;
84243     } catch (std::out_of_range& e) {
84244       {
84245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84246       };
84247     } catch (std::exception& e) {
84248       {
84249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84250       };
84251     } catch (...) {
84252       {
84253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84254       };
84255     }
84256   }
84257 }
84258
84259
84260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84261   unsigned int jresult ;
84262   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84263   bool result;
84264
84265   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84266   {
84267     try {
84268       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);
84269     } catch (std::out_of_range& e) {
84270       {
84271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84272       };
84273     } catch (std::exception& e) {
84274       {
84275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84276       };
84277     } catch (...) {
84278       {
84279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84280       };
84281     }
84282   }
84283   jresult = result;
84284   return jresult;
84285 }
84286
84287
84288 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84289   unsigned long jresult ;
84290   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84291   std::size_t result;
84292
84293   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84294   {
84295     try {
84296       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);
84297     } catch (std::out_of_range& e) {
84298       {
84299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84300       };
84301     } catch (std::exception& e) {
84302       {
84303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84304       };
84305     } catch (...) {
84306       {
84307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84308       };
84309     }
84310   }
84311   jresult = (unsigned long)result;
84312   return jresult;
84313 }
84314
84315
84316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84317   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84318   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84319
84320   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84321   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84322   {
84323     try {
84324       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84325     } catch (std::out_of_range& e) {
84326       {
84327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84328       };
84329     } catch (std::exception& e) {
84330       {
84331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84332       };
84333     } catch (...) {
84334       {
84335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84336       };
84337     }
84338   }
84339 }
84340
84341
84342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84343   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84344   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84345
84346   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84347   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84348   {
84349     try {
84350       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84351     } catch (std::out_of_range& e) {
84352       {
84353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84354       };
84355     } catch (std::exception& e) {
84356       {
84357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84358       };
84359     } catch (...) {
84360       {
84361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84362       };
84363     }
84364   }
84365 }
84366
84367
84368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84369   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84370   Dali::Toolkit::ProgressBar arg2 ;
84371   float arg3 ;
84372   float arg4 ;
84373   Dali::Toolkit::ProgressBar *argp2 ;
84374
84375   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84376   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84377   if (!argp2) {
84378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84379     return ;
84380   }
84381   arg2 = *argp2;
84382   arg3 = (float)jarg3;
84383   arg4 = (float)jarg4;
84384   {
84385     try {
84386       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84387     } catch (std::out_of_range& e) {
84388       {
84389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84390       };
84391     } catch (std::exception& e) {
84392       {
84393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84394       };
84395     } catch (...) {
84396       {
84397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84398       };
84399     }
84400   }
84401 }
84402
84403
84404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84405   void * jresult ;
84406   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84407
84408   {
84409     try {
84410       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (...) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84422       };
84423     }
84424   }
84425   jresult = (void *)result;
84426   return jresult;
84427 }
84428
84429
84430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84431   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84432
84433   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84434   {
84435     try {
84436       delete arg1;
84437     } catch (std::out_of_range& e) {
84438       {
84439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84440       };
84441     } catch (std::exception& e) {
84442       {
84443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84444       };
84445     } catch (...) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84448       };
84449     }
84450   }
84451 }
84452
84453
84454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84455   unsigned int jresult ;
84456   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84457   bool result;
84458
84459   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84460   {
84461     try {
84462       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);
84463     } catch (std::out_of_range& e) {
84464       {
84465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84466       };
84467     } catch (std::exception& e) {
84468       {
84469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84470       };
84471     } catch (...) {
84472       {
84473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84474       };
84475     }
84476   }
84477   jresult = result;
84478   return jresult;
84479 }
84480
84481
84482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84483   unsigned long jresult ;
84484   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84485   std::size_t result;
84486
84487   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84488   {
84489     try {
84490       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);
84491     } catch (std::out_of_range& e) {
84492       {
84493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (std::exception& e) {
84496       {
84497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (...) {
84500       {
84501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84502       };
84503     }
84504   }
84505   jresult = (unsigned long)result;
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84511   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84512   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84513
84514   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84515   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84516   {
84517     try {
84518       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84519     } catch (std::out_of_range& e) {
84520       {
84521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (std::exception& e) {
84524       {
84525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84526       };
84527     } catch (...) {
84528       {
84529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84530       };
84531     }
84532   }
84533 }
84534
84535
84536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84537   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84538   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84539
84540   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84541   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84542   {
84543     try {
84544       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84545     } catch (std::out_of_range& e) {
84546       {
84547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84548       };
84549     } catch (std::exception& e) {
84550       {
84551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84552       };
84553     } catch (...) {
84554       {
84555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84556       };
84557     }
84558   }
84559 }
84560
84561
84562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84563   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84564   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84565
84566   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84567   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84568   if (!arg2) {
84569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84570     return ;
84571   }
84572   {
84573     try {
84574       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84575     } catch (std::out_of_range& e) {
84576       {
84577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84578       };
84579     } catch (std::exception& e) {
84580       {
84581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84586       };
84587     }
84588   }
84589 }
84590
84591
84592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84593   void * jresult ;
84594   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84595
84596   {
84597     try {
84598       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (...) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84610       };
84611     }
84612   }
84613   jresult = (void *)result;
84614   return jresult;
84615 }
84616
84617
84618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84619   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84620
84621   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84622   {
84623     try {
84624       delete arg1;
84625     } catch (std::out_of_range& e) {
84626       {
84627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84628       };
84629     } catch (std::exception& e) {
84630       {
84631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84632       };
84633     } catch (...) {
84634       {
84635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84636       };
84637     }
84638   }
84639 }
84640
84641
84642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84643   unsigned int jresult ;
84644   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84645   bool result;
84646
84647   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84648   {
84649     try {
84650       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84651     } catch (std::out_of_range& e) {
84652       {
84653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84654       };
84655     } catch (std::exception& e) {
84656       {
84657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84658       };
84659     } catch (...) {
84660       {
84661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84662       };
84663     }
84664   }
84665   jresult = result;
84666   return jresult;
84667 }
84668
84669
84670 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84671   unsigned long jresult ;
84672   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84673   std::size_t result;
84674
84675   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84676   {
84677     try {
84678       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84679     } catch (std::out_of_range& e) {
84680       {
84681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (std::exception& e) {
84684       {
84685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84690       };
84691     }
84692   }
84693   jresult = (unsigned long)result;
84694   return jresult;
84695 }
84696
84697
84698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84699   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84700   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84701
84702   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84703   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84704   {
84705     try {
84706       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84707     } catch (std::out_of_range& e) {
84708       {
84709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84710       };
84711     } catch (std::exception& e) {
84712       {
84713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84714       };
84715     } catch (...) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84718       };
84719     }
84720   }
84721 }
84722
84723
84724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84725   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84726   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84727
84728   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84729   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84730   {
84731     try {
84732       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84733     } catch (std::out_of_range& e) {
84734       {
84735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84736       };
84737     } catch (std::exception& e) {
84738       {
84739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84740       };
84741     } catch (...) {
84742       {
84743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84744       };
84745     }
84746   }
84747 }
84748
84749
84750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84751   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84752   Dali::Vector2 *arg2 = 0 ;
84753
84754   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84755   arg2 = (Dali::Vector2 *)jarg2;
84756   if (!arg2) {
84757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84758     return ;
84759   }
84760   {
84761     try {
84762       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84781   void * jresult ;
84782   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84783
84784   {
84785     try {
84786       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (...) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84798       };
84799     }
84800   }
84801   jresult = (void *)result;
84802   return jresult;
84803 }
84804
84805
84806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84807   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84808
84809   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84810   {
84811     try {
84812       delete arg1;
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84824       };
84825     }
84826   }
84827 }
84828
84829
84830
84831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84832   unsigned int jresult ;
84833   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84834   bool result;
84835
84836   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84837   {
84838     try {
84839       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);
84840     } catch (std::out_of_range& e) {
84841       {
84842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84843       };
84844     } catch (std::exception& e) {
84845       {
84846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (...) {
84849       {
84850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84851       };
84852     }
84853   }
84854   jresult = result;
84855   return jresult;
84856 }
84857
84858
84859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84860   unsigned long jresult ;
84861   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84862   std::size_t result;
84863
84864   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84865   {
84866     try {
84867       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);
84868     } catch (std::out_of_range& e) {
84869       {
84870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84871       };
84872     } catch (std::exception& e) {
84873       {
84874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84875       };
84876     } catch (...) {
84877       {
84878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84879       };
84880     }
84881   }
84882   jresult = (unsigned long)result;
84883   return jresult;
84884 }
84885
84886
84887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84888   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84889   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84890
84891   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84892   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84893   {
84894     try {
84895       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84896     } catch (std::out_of_range& e) {
84897       {
84898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84899       };
84900     } catch (std::exception& e) {
84901       {
84902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84903       };
84904     } catch (...) {
84905       {
84906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84907       };
84908     }
84909   }
84910 }
84911
84912
84913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84914   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84915   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84916
84917   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84918   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84919   {
84920     try {
84921       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84929       };
84930     } catch (...) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84933       };
84934     }
84935   }
84936 }
84937
84938
84939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84940   unsigned int jresult ;
84941   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84942   Dali::Toolkit::Control arg2 ;
84943   Dali::KeyEvent *arg3 = 0 ;
84944   Dali::Toolkit::Control *argp2 ;
84945   bool result;
84946
84947   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84948   argp2 = (Dali::Toolkit::Control *)jarg2;
84949   if (!argp2) {
84950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84951     return 0;
84952   }
84953   arg2 = *argp2;
84954   arg3 = (Dali::KeyEvent *)jarg3;
84955   if (!arg3) {
84956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
84957     return 0;
84958   }
84959   {
84960     try {
84961       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);
84962     } catch (std::out_of_range& e) {
84963       {
84964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84965       };
84966     } catch (std::exception& e) {
84967       {
84968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84969       };
84970     } catch (...) {
84971       {
84972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84973       };
84974     }
84975   }
84976   jresult = result;
84977   return jresult;
84978 }
84979
84980
84981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
84982   void * jresult ;
84983   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
84984
84985   {
84986     try {
84987       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
84988     } catch (std::out_of_range& e) {
84989       {
84990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (std::exception& e) {
84993       {
84994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (...) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84999       };
85000     }
85001   }
85002   jresult = (void *)result;
85003   return jresult;
85004 }
85005
85006
85007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85008   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85009
85010   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85011   {
85012     try {
85013       delete arg1;
85014     } catch (std::out_of_range& e) {
85015       {
85016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85017       };
85018     } catch (std::exception& e) {
85019       {
85020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85021       };
85022     } catch (...) {
85023       {
85024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85025       };
85026     }
85027   }
85028 }
85029
85030
85031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85032   unsigned int jresult ;
85033   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85034   bool result;
85035
85036   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85037   {
85038     try {
85039       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85040     } catch (std::out_of_range& e) {
85041       {
85042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85043       };
85044     } catch (std::exception& e) {
85045       {
85046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85047       };
85048     } catch (...) {
85049       {
85050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85051       };
85052     }
85053   }
85054   jresult = result;
85055   return jresult;
85056 }
85057
85058
85059 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85060   unsigned long jresult ;
85061   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85062   std::size_t result;
85063
85064   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85065   {
85066     try {
85067       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85068     } catch (std::out_of_range& e) {
85069       {
85070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85071       };
85072     } catch (std::exception& e) {
85073       {
85074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85075       };
85076     } catch (...) {
85077       {
85078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85079       };
85080     }
85081   }
85082   jresult = (unsigned long)result;
85083   return jresult;
85084 }
85085
85086
85087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85088   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85089   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85090
85091   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85092   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85093   {
85094     try {
85095       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85096     } catch (std::out_of_range& e) {
85097       {
85098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85099       };
85100     } catch (std::exception& e) {
85101       {
85102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85103       };
85104     } catch (...) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85107       };
85108     }
85109   }
85110 }
85111
85112
85113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85114   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85115   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85116
85117   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85118   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85119   {
85120     try {
85121       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85122     } catch (std::out_of_range& e) {
85123       {
85124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85125       };
85126     } catch (std::exception& e) {
85127       {
85128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85133       };
85134     }
85135   }
85136 }
85137
85138
85139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85140   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85141   Dali::Toolkit::Control arg2 ;
85142   Dali::Toolkit::Control *argp2 ;
85143
85144   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85145   argp2 = (Dali::Toolkit::Control *)jarg2;
85146   if (!argp2) {
85147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85148     return ;
85149   }
85150   arg2 = *argp2;
85151   {
85152     try {
85153       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85154     } catch (std::out_of_range& e) {
85155       {
85156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85157       };
85158     } catch (std::exception& e) {
85159       {
85160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85161       };
85162     } catch (...) {
85163       {
85164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85165       };
85166     }
85167   }
85168 }
85169
85170
85171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85172   void * jresult ;
85173   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85174
85175   {
85176     try {
85177       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85178     } catch (std::out_of_range& e) {
85179       {
85180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (std::exception& e) {
85183       {
85184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85189       };
85190     }
85191   }
85192   jresult = (void *)result;
85193   return jresult;
85194 }
85195
85196
85197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85198   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85199
85200   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85201   {
85202     try {
85203       delete arg1;
85204     } catch (std::out_of_range& e) {
85205       {
85206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85207       };
85208     } catch (std::exception& e) {
85209       {
85210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85211       };
85212     } catch (...) {
85213       {
85214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85215       };
85216     }
85217   }
85218 }
85219
85220
85221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85222   unsigned int jresult ;
85223   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85224   bool result;
85225
85226   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85227   {
85228     try {
85229       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85230     } catch (std::out_of_range& e) {
85231       {
85232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85233       };
85234     } catch (std::exception& e) {
85235       {
85236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85237       };
85238     } catch (...) {
85239       {
85240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85241       };
85242     }
85243   }
85244   jresult = result;
85245   return jresult;
85246 }
85247
85248
85249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85250   unsigned long jresult ;
85251   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85252   std::size_t result;
85253
85254   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85255   {
85256     try {
85257       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85258     } catch (std::out_of_range& e) {
85259       {
85260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85261       };
85262     } catch (std::exception& e) {
85263       {
85264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85265       };
85266     } catch (...) {
85267       {
85268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85269       };
85270     }
85271   }
85272   jresult = (unsigned long)result;
85273   return jresult;
85274 }
85275
85276
85277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85278   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85279   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85280
85281   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85282   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85283   {
85284     try {
85285       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85286     } catch (std::out_of_range& e) {
85287       {
85288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85289       };
85290     } catch (std::exception& e) {
85291       {
85292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85293       };
85294     } catch (...) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85297       };
85298     }
85299   }
85300 }
85301
85302
85303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85304   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85305   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85306
85307   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85308   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85309   {
85310     try {
85311       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85312     } catch (std::out_of_range& e) {
85313       {
85314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85315       };
85316     } catch (std::exception& e) {
85317       {
85318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85319       };
85320     } catch (...) {
85321       {
85322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85323       };
85324     }
85325   }
85326 }
85327
85328
85329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85330   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85331   Dali::Toolkit::VideoView *arg2 = 0 ;
85332
85333   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85334   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85335   if (!arg2) {
85336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85337     return ;
85338   }
85339   {
85340     try {
85341       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85342     } catch (std::out_of_range& e) {
85343       {
85344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85345       };
85346     } catch (std::exception& e) {
85347       {
85348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85349       };
85350     } catch (...) {
85351       {
85352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85353       };
85354     }
85355   }
85356 }
85357
85358
85359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85360   void * jresult ;
85361   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85362
85363   {
85364     try {
85365       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85366     } catch (std::out_of_range& e) {
85367       {
85368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (std::exception& e) {
85371       {
85372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85373       };
85374     } catch (...) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85377       };
85378     }
85379   }
85380   jresult = (void *)result;
85381   return jresult;
85382 }
85383
85384
85385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85386   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85387
85388   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85389   {
85390     try {
85391       delete arg1;
85392     } catch (std::out_of_range& e) {
85393       {
85394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85395       };
85396     } catch (std::exception& e) {
85397       {
85398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85399       };
85400     } catch (...) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85403       };
85404     }
85405   }
85406 }
85407
85408
85409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85410   unsigned int jresult ;
85411   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85412   bool result;
85413
85414   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85415   {
85416     try {
85417       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85418     } catch (std::out_of_range& e) {
85419       {
85420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85421       };
85422     } catch (std::exception& e) {
85423       {
85424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85425       };
85426     } catch (...) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85429       };
85430     }
85431   }
85432   jresult = result;
85433   return jresult;
85434 }
85435
85436
85437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85438   unsigned long jresult ;
85439   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85440   std::size_t result;
85441
85442   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85443   {
85444     try {
85445       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85446     } catch (std::out_of_range& e) {
85447       {
85448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85449       };
85450     } catch (std::exception& e) {
85451       {
85452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85453       };
85454     } catch (...) {
85455       {
85456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85457       };
85458     }
85459   }
85460   jresult = (unsigned long)result;
85461   return jresult;
85462 }
85463
85464
85465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85466   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85467   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85468
85469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85470   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85471   {
85472     try {
85473       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85474     } catch (std::out_of_range& e) {
85475       {
85476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85477       };
85478     } catch (std::exception& e) {
85479       {
85480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85481       };
85482     } catch (...) {
85483       {
85484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85485       };
85486     }
85487   }
85488 }
85489
85490
85491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85492   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85493   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85494
85495   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85496   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85497   {
85498     try {
85499       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85500     } catch (std::out_of_range& e) {
85501       {
85502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85503       };
85504     } catch (std::exception& e) {
85505       {
85506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85507       };
85508     } catch (...) {
85509       {
85510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85511       };
85512     }
85513   }
85514 }
85515
85516
85517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85518   unsigned int jresult ;
85519   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85520   Dali::Toolkit::Slider arg2 ;
85521   float arg3 ;
85522   Dali::Toolkit::Slider *argp2 ;
85523   bool result;
85524
85525   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85526   argp2 = (Dali::Toolkit::Slider *)jarg2;
85527   if (!argp2) {
85528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85529     return 0;
85530   }
85531   arg2 = *argp2;
85532   arg3 = (float)jarg3;
85533   {
85534     try {
85535       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85536     } catch (std::out_of_range& e) {
85537       {
85538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85539       };
85540     } catch (std::exception& e) {
85541       {
85542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85543       };
85544     } catch (...) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85547       };
85548     }
85549   }
85550   jresult = result;
85551   return jresult;
85552 }
85553
85554
85555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85556   void * jresult ;
85557   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85558
85559   {
85560     try {
85561       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85562     } catch (std::out_of_range& e) {
85563       {
85564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85565       };
85566     } catch (std::exception& e) {
85567       {
85568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85569       };
85570     } catch (...) {
85571       {
85572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85573       };
85574     }
85575   }
85576   jresult = (void *)result;
85577   return jresult;
85578 }
85579
85580
85581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85582   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85583
85584   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85585   {
85586     try {
85587       delete arg1;
85588     } catch (std::out_of_range& e) {
85589       {
85590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85591       };
85592     } catch (std::exception& e) {
85593       {
85594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85599       };
85600     }
85601   }
85602 }
85603
85604
85605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85606   unsigned int jresult ;
85607   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85608   bool result;
85609
85610   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85611   {
85612     try {
85613       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85614     } catch (std::out_of_range& e) {
85615       {
85616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85617       };
85618     } catch (std::exception& e) {
85619       {
85620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85621       };
85622     } catch (...) {
85623       {
85624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85625       };
85626     }
85627   }
85628   jresult = result;
85629   return jresult;
85630 }
85631
85632
85633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85634   unsigned long jresult ;
85635   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85636   std::size_t result;
85637
85638   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85639   {
85640     try {
85641       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85642     } catch (std::out_of_range& e) {
85643       {
85644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85645       };
85646     } catch (std::exception& e) {
85647       {
85648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85649       };
85650     } catch (...) {
85651       {
85652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85653       };
85654     }
85655   }
85656   jresult = (unsigned long)result;
85657   return jresult;
85658 }
85659
85660
85661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85662   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85663   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85664
85665   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85666   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85667   {
85668     try {
85669       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85670     } catch (std::out_of_range& e) {
85671       {
85672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85673       };
85674     } catch (std::exception& e) {
85675       {
85676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85677       };
85678     } catch (...) {
85679       {
85680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85681       };
85682     }
85683   }
85684 }
85685
85686
85687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85688   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85689   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85690
85691   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85692   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85693   {
85694     try {
85695       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85696     } catch (std::out_of_range& e) {
85697       {
85698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85699       };
85700     } catch (std::exception& e) {
85701       {
85702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85703       };
85704     } catch (...) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85707       };
85708     }
85709   }
85710 }
85711
85712
85713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85714   unsigned int jresult ;
85715   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85716   Dali::Toolkit::Slider arg2 ;
85717   int arg3 ;
85718   Dali::Toolkit::Slider *argp2 ;
85719   bool result;
85720
85721   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85722   argp2 = (Dali::Toolkit::Slider *)jarg2;
85723   if (!argp2) {
85724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85725     return 0;
85726   }
85727   arg2 = *argp2;
85728   arg3 = (int)jarg3;
85729   {
85730     try {
85731       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85732     } catch (std::out_of_range& e) {
85733       {
85734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85735       };
85736     } catch (std::exception& e) {
85737       {
85738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85739       };
85740     } catch (...) {
85741       {
85742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85743       };
85744     }
85745   }
85746   jresult = result;
85747   return jresult;
85748 }
85749
85750
85751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85752   void * jresult ;
85753   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85754
85755   {
85756     try {
85757       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (...) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85769       };
85770     }
85771   }
85772   jresult = (void *)result;
85773   return jresult;
85774 }
85775
85776
85777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85778   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85779
85780   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85781   {
85782     try {
85783       delete arg1;
85784     } catch (std::out_of_range& e) {
85785       {
85786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85787       };
85788     } catch (std::exception& e) {
85789       {
85790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85791       };
85792     } catch (...) {
85793       {
85794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85795       };
85796     }
85797   }
85798 }
85799
85800
85801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85802   void * jresult ;
85803   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85804
85805   {
85806     try {
85807       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85808     } catch (std::out_of_range& e) {
85809       {
85810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85811       };
85812     } catch (std::exception& e) {
85813       {
85814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85815       };
85816     } catch (...) {
85817       {
85818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85819       };
85820     }
85821   }
85822   jresult = (void *)result;
85823   return jresult;
85824 }
85825
85826
85827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85828   void * jresult ;
85829   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85831
85832   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85833   {
85834     try {
85835       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85836     } catch (std::out_of_range& e) {
85837       {
85838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85839       };
85840     } catch (std::exception& e) {
85841       {
85842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85843       };
85844     } catch (...) {
85845       {
85846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85847       };
85848     }
85849   }
85850   jresult = (void *)result;
85851   return jresult;
85852 }
85853
85854
85855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85856   void * jresult ;
85857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85858   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85859
85860   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85861   if (!arg1) {
85862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85863     return 0;
85864   }
85865   {
85866     try {
85867       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85868     } catch (std::out_of_range& e) {
85869       {
85870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (std::exception& e) {
85873       {
85874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85875       };
85876     } catch (...) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85879       };
85880     }
85881   }
85882   jresult = (void *)result;
85883   return jresult;
85884 }
85885
85886
85887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85888   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85889
85890   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85891   {
85892     try {
85893       delete arg1;
85894     } catch (std::out_of_range& e) {
85895       {
85896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85897       };
85898     } catch (std::exception& e) {
85899       {
85900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85905       };
85906     }
85907   }
85908 }
85909
85910
85911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85912   void * jresult ;
85913   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85914   Dali::Toolkit::Ruler *result = 0 ;
85915
85916   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85917   {
85918     try {
85919       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
85920     } catch (std::out_of_range& e) {
85921       {
85922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (std::exception& e) {
85925       {
85926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85927       };
85928     } catch (...) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85931       };
85932     }
85933   }
85934   jresult = (void *)result;
85935   return jresult;
85936 }
85937
85938
85939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85940   void * jresult ;
85941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85942   Dali::Toolkit::Ruler *result = 0 ;
85943
85944   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85945   {
85946     try {
85947       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85948     } catch (std::out_of_range& e) {
85949       {
85950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85951       };
85952     } catch (std::exception& e) {
85953       {
85954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85955       };
85956     } catch (...) {
85957       {
85958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85959       };
85960     }
85961   }
85962   jresult = (void *)result;
85963   return jresult;
85964 }
85965
85966
85967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
85968   void * jresult ;
85969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85970   Dali::Toolkit::Ruler *result = 0 ;
85971
85972   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85973   {
85974     try {
85975       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
85976     } catch (std::out_of_range& e) {
85977       {
85978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (std::exception& e) {
85981       {
85982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (...) {
85985       {
85986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85987       };
85988     }
85989   }
85990   jresult = (void *)result;
85991   return jresult;
85992 }
85993
85994
85995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
85996   void * jresult ;
85997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
85999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86000
86001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86002   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86003   if (!arg2) {
86004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86005     return 0;
86006   }
86007   {
86008     try {
86009       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86010     } catch (std::out_of_range& e) {
86011       {
86012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86013       };
86014     } catch (std::exception& e) {
86015       {
86016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86017       };
86018     } catch (...) {
86019       {
86020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86021       };
86022     }
86023   }
86024   jresult = (void *)result;
86025   return jresult;
86026 }
86027
86028
86029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86030   void * jresult ;
86031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86032   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86034
86035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86036   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86037   {
86038     try {
86039       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86040     } catch (std::out_of_range& e) {
86041       {
86042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86043       };
86044     } catch (std::exception& e) {
86045       {
86046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86047       };
86048     } catch (...) {
86049       {
86050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86051       };
86052     }
86053   }
86054   jresult = (void *)result;
86055   return jresult;
86056 }
86057
86058
86059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86060   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86061
86062   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86063   {
86064     try {
86065       (arg1)->Reset();
86066     } catch (std::out_of_range& e) {
86067       {
86068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86069       };
86070     } catch (std::exception& e) {
86071       {
86072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86073       };
86074     } catch (...) {
86075       {
86076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86077       };
86078     }
86079   }
86080 }
86081
86082
86083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86085   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86086
86087   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86088   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86089   {
86090     try {
86091       (arg1)->Reset(arg2);
86092     } catch (std::out_of_range& e) {
86093       {
86094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86095       };
86096     } catch (std::exception& e) {
86097       {
86098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86103       };
86104     }
86105   }
86106 }
86107
86108
86109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86110   void * jresult ;
86111   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86112   Dali::Toolkit::Ruler *result = 0 ;
86113
86114   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86115   {
86116     try {
86117       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86118     } catch (std::out_of_range& e) {
86119       {
86120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (std::exception& e) {
86123       {
86124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86125       };
86126     } catch (...) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86129       };
86130     }
86131   }
86132   jresult = (void *)result;
86133   return jresult;
86134 }
86135
86136
86137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86138   float jresult ;
86139   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86140   float arg2 ;
86141   float arg3 ;
86142   float result;
86143
86144   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86145   arg2 = (float)jarg2;
86146   arg3 = (float)jarg3;
86147   {
86148     try {
86149       result = (float)(*arg1)->Snap(arg2,arg3);
86150     } catch (std::out_of_range& e) {
86151       {
86152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86153       };
86154     } catch (std::exception& e) {
86155       {
86156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (...) {
86159       {
86160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86161       };
86162     }
86163   }
86164   jresult = result;
86165   return jresult;
86166 }
86167
86168
86169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86170   float jresult ;
86171   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86172   float arg2 ;
86173   float result;
86174
86175   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86176   arg2 = (float)jarg2;
86177   {
86178     try {
86179       result = (float)(*arg1)->Snap(arg2);
86180     } catch (std::out_of_range& e) {
86181       {
86182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86183       };
86184     } catch (std::exception& e) {
86185       {
86186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (...) {
86189       {
86190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86191       };
86192     }
86193   }
86194   jresult = result;
86195   return jresult;
86196 }
86197
86198
86199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86200   float jresult ;
86201   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86202   unsigned int arg2 ;
86203   unsigned int *arg3 = 0 ;
86204   bool arg4 ;
86205   float result;
86206
86207   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86208   arg2 = (unsigned int)jarg2;
86209   arg3 = (unsigned int *)jarg3;
86210   arg4 = jarg4 ? true : false;
86211   {
86212     try {
86213       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86214     } catch (std::out_of_range& e) {
86215       {
86216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86217       };
86218     } catch (std::exception& e) {
86219       {
86220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (...) {
86223       {
86224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86225       };
86226     }
86227   }
86228   jresult = result;
86229   return jresult;
86230 }
86231
86232
86233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86234   unsigned int jresult ;
86235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86236   float arg2 ;
86237   bool arg3 ;
86238   unsigned int result;
86239
86240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86241   arg2 = (float)jarg2;
86242   arg3 = jarg3 ? true : false;
86243   {
86244     try {
86245       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86246     } catch (std::out_of_range& e) {
86247       {
86248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86249       };
86250     } catch (std::exception& e) {
86251       {
86252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86253       };
86254     } catch (...) {
86255       {
86256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86257       };
86258     }
86259   }
86260   jresult = result;
86261   return jresult;
86262 }
86263
86264
86265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86266   unsigned int jresult ;
86267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86268   unsigned int result;
86269
86270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86271   {
86272     try {
86273       result = (unsigned int)(*arg1)->GetTotalPages();
86274     } catch (std::out_of_range& e) {
86275       {
86276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86277       };
86278     } catch (std::exception& e) {
86279       {
86280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (...) {
86283       {
86284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86285       };
86286     }
86287   }
86288   jresult = result;
86289   return jresult;
86290 }
86291
86292
86293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86294   int jresult ;
86295   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86296   Dali::Toolkit::Ruler::RulerType result;
86297
86298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86299   {
86300     try {
86301       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86302     } catch (std::out_of_range& e) {
86303       {
86304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86305       };
86306     } catch (std::exception& e) {
86307       {
86308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86309       };
86310     } catch (...) {
86311       {
86312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86313       };
86314     }
86315   }
86316   jresult = (int)result;
86317   return jresult;
86318 }
86319
86320
86321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86322   unsigned int jresult ;
86323   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86324   bool result;
86325
86326   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86327   {
86328     try {
86329       result = (bool)(*arg1)->IsEnabled();
86330     } catch (std::out_of_range& e) {
86331       {
86332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86333       };
86334     } catch (std::exception& e) {
86335       {
86336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86337       };
86338     } catch (...) {
86339       {
86340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86341       };
86342     }
86343   }
86344   jresult = result;
86345   return jresult;
86346 }
86347
86348
86349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86350   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86351
86352   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86353   {
86354     try {
86355       (*arg1)->Enable();
86356     } catch (std::out_of_range& e) {
86357       {
86358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86359       };
86360     } catch (std::exception& e) {
86361       {
86362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86363       };
86364     } catch (...) {
86365       {
86366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86367       };
86368     }
86369   }
86370 }
86371
86372
86373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86375
86376   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86377   {
86378     try {
86379       (*arg1)->Disable();
86380     } catch (std::out_of_range& e) {
86381       {
86382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86383       };
86384     } catch (std::exception& e) {
86385       {
86386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86387       };
86388     } catch (...) {
86389       {
86390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86391       };
86392     }
86393   }
86394 }
86395
86396
86397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86398   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86399   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86400   Dali::Toolkit::RulerDomain *argp2 ;
86401
86402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86403   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86404   if (!argp2) {
86405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86406     return ;
86407   }
86408   arg2 = *argp2;
86409   {
86410     try {
86411       (*arg1)->SetDomain(arg2);
86412     } catch (std::out_of_range& e) {
86413       {
86414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86415       };
86416     } catch (std::exception& e) {
86417       {
86418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86419       };
86420     } catch (...) {
86421       {
86422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86423       };
86424     }
86425   }
86426 }
86427
86428
86429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86430   void * jresult ;
86431   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86432   Dali::Toolkit::RulerDomain *result = 0 ;
86433
86434   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86435   {
86436     try {
86437       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86438     } catch (std::out_of_range& e) {
86439       {
86440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86441       };
86442     } catch (std::exception& e) {
86443       {
86444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86445       };
86446     } catch (...) {
86447       {
86448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86449       };
86450     }
86451   }
86452   jresult = (void *)result;
86453   return jresult;
86454 }
86455
86456
86457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86458   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86459
86460   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86461   {
86462     try {
86463       (*arg1)->DisableDomain();
86464     } catch (std::out_of_range& e) {
86465       {
86466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86467       };
86468     } catch (std::exception& e) {
86469       {
86470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86471       };
86472     } catch (...) {
86473       {
86474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86475       };
86476     }
86477   }
86478 }
86479
86480
86481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86482   float jresult ;
86483   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86484   float arg2 ;
86485   float arg3 ;
86486   float arg4 ;
86487   float result;
86488
86489   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86490   arg2 = (float)jarg2;
86491   arg3 = (float)jarg3;
86492   arg4 = (float)jarg4;
86493   {
86494     try {
86495       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86496     } catch (std::out_of_range& e) {
86497       {
86498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86499       };
86500     } catch (std::exception& e) {
86501       {
86502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (...) {
86505       {
86506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86507       };
86508     }
86509   }
86510   jresult = result;
86511   return jresult;
86512 }
86513
86514
86515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86516   float jresult ;
86517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86518   float arg2 ;
86519   float arg3 ;
86520   float result;
86521
86522   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86523   arg2 = (float)jarg2;
86524   arg3 = (float)jarg3;
86525   {
86526     try {
86527       result = (float)(*arg1)->Clamp(arg2,arg3);
86528     } catch (std::out_of_range& e) {
86529       {
86530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (std::exception& e) {
86533       {
86534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (...) {
86537       {
86538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86539       };
86540     }
86541   }
86542   jresult = result;
86543   return jresult;
86544 }
86545
86546
86547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86548   float jresult ;
86549   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86550   float arg2 ;
86551   float result;
86552
86553   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86554   arg2 = (float)jarg2;
86555   {
86556     try {
86557       result = (float)(*arg1)->Clamp(arg2);
86558     } catch (std::out_of_range& e) {
86559       {
86560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86561       };
86562     } catch (std::exception& e) {
86563       {
86564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86565       };
86566     } catch (...) {
86567       {
86568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86569       };
86570     }
86571   }
86572   jresult = result;
86573   return jresult;
86574 }
86575
86576
86577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86578   float jresult ;
86579   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86580   float arg2 ;
86581   float arg3 ;
86582   float arg4 ;
86583   Dali::Toolkit::ClampState *arg5 = 0 ;
86584   float result;
86585
86586   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86587   arg2 = (float)jarg2;
86588   arg3 = (float)jarg3;
86589   arg4 = (float)jarg4;
86590   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86591   if (!arg5) {
86592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86593     return 0;
86594   }
86595   {
86596     try {
86597       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86598     } catch (std::out_of_range& e) {
86599       {
86600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (std::exception& e) {
86603       {
86604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86605       };
86606     } catch (...) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86609       };
86610     }
86611   }
86612   jresult = result;
86613   return jresult;
86614 }
86615
86616
86617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86618   float jresult ;
86619   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86620   float arg2 ;
86621   float arg3 ;
86622   float arg4 ;
86623   float arg5 ;
86624   float result;
86625
86626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86627   arg2 = (float)jarg2;
86628   arg3 = (float)jarg3;
86629   arg4 = (float)jarg4;
86630   arg5 = (float)jarg5;
86631   {
86632     try {
86633       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86634     } catch (std::out_of_range& e) {
86635       {
86636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86637       };
86638     } catch (std::exception& e) {
86639       {
86640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86641       };
86642     } catch (...) {
86643       {
86644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86645       };
86646     }
86647   }
86648   jresult = result;
86649   return jresult;
86650 }
86651
86652
86653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86654   float jresult ;
86655   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86656   float arg2 ;
86657   float arg3 ;
86658   float arg4 ;
86659   float result;
86660
86661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86662   arg2 = (float)jarg2;
86663   arg3 = (float)jarg3;
86664   arg4 = (float)jarg4;
86665   {
86666     try {
86667       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86668     } catch (std::out_of_range& e) {
86669       {
86670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86671       };
86672     } catch (std::exception& e) {
86673       {
86674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86675       };
86676     } catch (...) {
86677       {
86678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86679       };
86680     }
86681   }
86682   jresult = result;
86683   return jresult;
86684 }
86685
86686
86687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86688   float jresult ;
86689   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86690   float arg2 ;
86691   float arg3 ;
86692   float result;
86693
86694   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86695   arg2 = (float)jarg2;
86696   arg3 = (float)jarg3;
86697   {
86698     try {
86699       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86700     } catch (std::out_of_range& e) {
86701       {
86702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86703       };
86704     } catch (std::exception& e) {
86705       {
86706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86707       };
86708     } catch (...) {
86709       {
86710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86711       };
86712     }
86713   }
86714   jresult = result;
86715   return jresult;
86716 }
86717
86718
86719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86720   float jresult ;
86721   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86722   float arg2 ;
86723   float result;
86724
86725   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86726   arg2 = (float)jarg2;
86727   {
86728     try {
86729       result = (float)(*arg1)->SnapAndClamp(arg2);
86730     } catch (std::out_of_range& e) {
86731       {
86732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86733       };
86734     } catch (std::exception& e) {
86735       {
86736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86737       };
86738     } catch (...) {
86739       {
86740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86741       };
86742     }
86743   }
86744   jresult = result;
86745   return jresult;
86746 }
86747
86748
86749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86750   float jresult ;
86751   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86752   float arg2 ;
86753   float arg3 ;
86754   float arg4 ;
86755   float arg5 ;
86756   Dali::Toolkit::ClampState *arg6 = 0 ;
86757   float result;
86758
86759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86760   arg2 = (float)jarg2;
86761   arg3 = (float)jarg3;
86762   arg4 = (float)jarg4;
86763   arg5 = (float)jarg5;
86764   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86765   if (!arg6) {
86766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86767     return 0;
86768   }
86769   {
86770     try {
86771       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86772     } catch (std::out_of_range& e) {
86773       {
86774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (std::exception& e) {
86777       {
86778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786   jresult = result;
86787   return jresult;
86788 }
86789
86790
86791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86793
86794   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86795   {
86796     try {
86797       (*arg1)->Reference();
86798     } catch (std::out_of_range& e) {
86799       {
86800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86801       };
86802     } catch (std::exception& e) {
86803       {
86804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86805       };
86806     } catch (...) {
86807       {
86808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86809       };
86810     }
86811   }
86812 }
86813
86814
86815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86816   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86817
86818   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86819   {
86820     try {
86821       (*arg1)->Unreference();
86822     } catch (std::out_of_range& e) {
86823       {
86824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86825       };
86826     } catch (std::exception& e) {
86827       {
86828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86829       };
86830     } catch (...) {
86831       {
86832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86833       };
86834     }
86835   }
86836 }
86837
86838
86839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86840   int jresult ;
86841   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86842   int result;
86843
86844   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86845   {
86846     try {
86847       result = (int)(*arg1)->ReferenceCount();
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (...) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86859       };
86860     }
86861   }
86862   jresult = result;
86863   return jresult;
86864 }
86865
86866
86867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86868   unsigned int jresult ;
86869   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86870   bool result;
86871
86872   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86873   {
86874     try {
86875       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86876     } catch (std::out_of_range& e) {
86877       {
86878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (std::exception& e) {
86881       {
86882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86887       };
86888     }
86889   }
86890   jresult = result;
86891   return jresult;
86892 }
86893
86894
86895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86896   unsigned long jresult ;
86897   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86898   std::size_t result;
86899
86900   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86901   {
86902     try {
86903       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86904     } catch (std::out_of_range& e) {
86905       {
86906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86907       };
86908     } catch (std::exception& e) {
86909       {
86910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (...) {
86913       {
86914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86915       };
86916     }
86917   }
86918   jresult = (unsigned long)result;
86919   return jresult;
86920 }
86921
86922
86923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86924   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86925   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86926
86927   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86928   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86929   {
86930     try {
86931       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86932     } catch (std::out_of_range& e) {
86933       {
86934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86935       };
86936     } catch (std::exception& e) {
86937       {
86938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86939       };
86940     } catch (...) {
86941       {
86942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86943       };
86944     }
86945   }
86946 }
86947
86948
86949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86950   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86951   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86952
86953   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86954   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86955   {
86956     try {
86957       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86958     } catch (std::out_of_range& e) {
86959       {
86960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86961       };
86962     } catch (std::exception& e) {
86963       {
86964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86965       };
86966     } catch (...) {
86967       {
86968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86969       };
86970     }
86971   }
86972 }
86973
86974
86975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
86976   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86977   Dali::Toolkit::Control arg2 ;
86978   Dali::Toolkit::Control *argp2 ;
86979
86980   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86981   argp2 = (Dali::Toolkit::Control *)jarg2;
86982   if (!argp2) {
86983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86984     return ;
86985   }
86986   arg2 = *argp2;
86987   {
86988     try {
86989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
86990     } catch (std::out_of_range& e) {
86991       {
86992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86993       };
86994     } catch (std::exception& e) {
86995       {
86996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86997       };
86998     } catch (...) {
86999       {
87000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87001       };
87002     }
87003   }
87004 }
87005
87006
87007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87008   void * jresult ;
87009   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87010
87011   {
87012     try {
87013       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87014     } catch (std::out_of_range& e) {
87015       {
87016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87017       };
87018     } catch (std::exception& e) {
87019       {
87020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87021       };
87022     } catch (...) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87025       };
87026     }
87027   }
87028   jresult = (void *)result;
87029   return jresult;
87030 }
87031
87032
87033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87034   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87035
87036   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87037   {
87038     try {
87039       delete arg1;
87040     } catch (std::out_of_range& e) {
87041       {
87042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87043       };
87044     } catch (std::exception& e) {
87045       {
87046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87047       };
87048     } catch (...) {
87049       {
87050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87051       };
87052     }
87053   }
87054 }
87055
87056 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87057   Dali::RefObject *result = NULL;
87058
87059   if (arg1)
87060   {
87061     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87062   }
87063   return result;
87064 }
87065
87066 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87067     return (Dali::RefObject *)jarg1;
87068 }
87069
87070 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87071     return (Dali::SignalObserver *)jarg1;
87072 }
87073
87074 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87075     return (Dali::ConnectionTrackerInterface *)jarg1;
87076 }
87077
87078 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87079     return (Dali::BaseHandle *)jarg1;
87080 }
87081
87082 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87083     return (Dali::BaseHandle *)jarg1;
87084 }
87085
87086 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87087     return (Dali::BaseHandle *)jarg1;
87088 }
87089
87090 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87091     return (Dali::BaseHandle *)jarg1;
87092 }
87093
87094 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87095     return (Dali::BaseHandle *)jarg1;
87096 }
87097
87098 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87099     return (Dali::BaseHandle *)jarg1;
87100 }
87101
87102 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87103     return (Dali::BaseHandle *)jarg1;
87104 }
87105
87106 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87107     return (Dali::BaseHandle *)jarg1;
87108 }
87109
87110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87111     return (Dali::BaseHandle *)jarg1;
87112 }
87113
87114 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87115     return (Dali::BaseHandle *)jarg1;
87116 }
87117
87118 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87119     return (Dali::BaseHandle *)jarg1;
87120 }
87121
87122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87123     return (Dali::BaseHandle *)jarg1;
87124 }
87125
87126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87127     return (Dali::BaseHandle *)jarg1;
87128 }
87129
87130 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87131     return (Dali::Handle *)jarg1;
87132 }
87133
87134 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87135     return (Dali::Handle *)jarg1;
87136 }
87137
87138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87139     return (Dali::BaseHandle *)jarg1;
87140 }
87141
87142 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87143     return (Dali::BaseHandle *)jarg1;
87144 }
87145
87146 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87147     return (Dali::Handle *)jarg1;
87148 }
87149
87150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87151     return (Dali::BaseHandle *)jarg1;
87152 }
87153
87154 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87155     return (Dali::Handle *)jarg1;
87156 }
87157
87158 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87159     return (Dali::GestureDetector *)jarg1;
87160 }
87161
87162 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87163     return (Dali::Gesture *)jarg1;
87164 }
87165
87166 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87167     return (Dali::Handle *)jarg1;
87168 }
87169
87170 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87171     return (Dali::Actor *)jarg1;
87172 }
87173
87174 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87175     return (Dali::BaseHandle *)jarg1;
87176 }
87177
87178 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87179     return (Dali::RefObject *)jarg1;
87180 }
87181
87182 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87183     return (Dali::Actor *)jarg1;
87184 }
87185
87186 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87187     return (Dali::GestureDetector *)jarg1;
87188 }
87189
87190 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87191     return (Dali::Gesture *)jarg1;
87192 }
87193
87194 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87195     return (Dali::GestureDetector *)jarg1;
87196 }
87197
87198 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87199     return (Dali::Gesture *)jarg1;
87200 }
87201
87202 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87203     return (Dali::GestureDetector *)jarg1;
87204 }
87205
87206 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87207     return (Dali::Gesture *)jarg1;
87208 }
87209
87210 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87211     return (Dali::BaseHandle *)jarg1;
87212 }
87213
87214 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87215     return (Dali::Handle *)jarg1;
87216 }
87217
87218 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87219     return (Dali::Handle *)jarg1;
87220 }
87221
87222 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87223     return (Dali::Handle *)jarg1;
87224 }
87225
87226 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87227     return (Dali::Image *)jarg1;
87228 }
87229
87230 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87231     return (Dali::Image *)jarg1;
87232 }
87233
87234 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87235     return (Dali::Image *)jarg1;
87236 }
87237
87238 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87239     return (Dali::RefObject *)jarg1;
87240 }
87241
87242 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87243     return (Dali::Image *)jarg1;
87244 }
87245
87246 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87247     return (Dali::Image *)jarg1;
87248 }
87249
87250 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87251     return (Dali::ResourceImage *)jarg1;
87252 }
87253
87254 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87255     return (Dali::Actor *)jarg1;
87256 }
87257
87258 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87259     return (Dali::BaseHandle *)jarg1;
87260 }
87261
87262 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87263     return (Dali::BaseHandle *)jarg1;
87264 }
87265
87266
87267 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87268     return (Dali::BaseHandle *)jarg1;
87269 }
87270
87271 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87272     return (Dali::BaseHandle *)jarg1;
87273 }
87274
87275 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87276     return (Dali::CustomActorImpl *)jarg1;
87277 }
87278
87279 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87280     return (Dali::CustomActor *)jarg1;
87281 }
87282
87283 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87284     return (Dali::BaseHandle *)jarg1;
87285 }
87286
87287 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87288     return (Dali::Toolkit::Control *)jarg1;
87289 }
87290
87291 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87292     return (Dali::Toolkit::Control *)jarg1;
87293 }
87294
87295 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87296     return (Dali::Toolkit::Button *)jarg1;
87297 }
87298
87299 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87300     return (Dali::Toolkit::Button *)jarg1;
87301 }
87302
87303 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87304     return (Dali::Toolkit::Button *)jarg1;
87305 }
87306
87307 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87308     return (Dali::Toolkit::Control *)jarg1;
87309 }
87310
87311 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87312     return (Dali::Toolkit::Control *)jarg1;
87313 }
87314
87315 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87316     return (Dali::Toolkit::Control *)jarg1;
87317 }
87318
87319 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87320     return (Dali::Toolkit::Control *)jarg1;
87321 }
87322
87323 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87324     return (Dali::Toolkit::Control *)jarg1;
87325 }
87326
87327 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87328     return (Dali::RefObject *)jarg1;
87329 }
87330
87331 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87332     return (Dali::Toolkit::Scrollable *)jarg1;
87333 }
87334
87335 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87336     return (Dali::BaseHandle *)jarg1;
87337 }
87338
87339 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87340     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87341 }
87342
87343 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87344     return (Dali::RefObject *)jarg1;
87345 }
87346
87347 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87348     return (Dali::Toolkit::Ruler *)jarg1;
87349 }
87350
87351 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87352     return (Dali::Toolkit::Ruler *)jarg1;
87353 }
87354
87355 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87356     return (Dali::Toolkit::Scrollable *)jarg1;
87357 }
87358
87359 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87360     return (Dali::Toolkit::Control *)jarg1;
87361 }
87362
87363
87364 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87365     return (Dali::Toolkit::Control *)jarg1;
87366 }
87367
87368 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87369     return (Dali::BaseHandle *)jarg1;
87370 }
87371
87372 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87373     return (Dali::BaseHandle *)jarg1;
87374 }
87375
87376 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87377     return (Dali::Toolkit::Control *)jarg1;
87378 }
87379
87380 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87381     return (Dali::Toolkit::Control *)jarg1;
87382 }
87383
87384 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87385     return (Dali::Toolkit::Control *)jarg1;
87386 }
87387
87388 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87389     return (Dali::Toolkit::Control *)jarg1;
87390 }
87391
87392 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87393     return (Dali::Toolkit::Control *)jarg1;
87394 }
87395
87396 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87397     return (Dali::Toolkit::Control *)jarg1;
87398 }
87399
87400 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87401     return (Dali::Toolkit::PageTurnView *)jarg1;
87402 }
87403
87404 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87405     return (Dali::Toolkit::PageTurnView *)jarg1;
87406 }
87407
87408 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87409     return (Dali::Toolkit::Button *)jarg1;
87410 }
87411
87412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87413     return (Dali::BaseHandle *)jarg1;
87414 }
87415
87416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87417     return (Dali::BaseHandle *)jarg1;
87418 }
87419
87420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87421     return (Dali::BaseHandle *)jarg1;
87422 }
87423
87424
87425 #ifdef __cplusplus
87426 }
87427 #endif