dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 456 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458
 459 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 460 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 461 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 462
 463 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/image-visual-properties.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 = arg1->GetDeviceName();
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::Device::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::Device::Class::Type)arg1->GetDeviceClass();
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       arg1.Raise();
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       arg1.Lower();
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       arg1.RaiseToTop();
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       arg1.LowerToBottom();
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       arg1.RaiseAbove(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       arg1.LowerBelow(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::ImageVisual::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::ImageVisual::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::ImageVisual::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::ImageVisual::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::ImageVisual::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::ImageVisual::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 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
52420   int jresult ;
52421   int result;
52422
52423   {
52424     try {
52425       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (...) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52437       };
52438     }
52439   }
52440   jresult = (int)result;
52441   return jresult;
52442 }
52443
52444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52445   int jresult ;
52446   int result;
52447
52448   {
52449     try {
52450       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52451     } catch (std::out_of_range& e) {
52452       {
52453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52454       };
52455     } catch (std::exception& e) {
52456       {
52457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52458       };
52459     } catch (...) {
52460       {
52461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52462       };
52463     }
52464   }
52465   jresult = (int)result;
52466   return jresult;
52467 }
52468
52469
52470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52471   int jresult ;
52472   int result;
52473
52474   {
52475     try {
52476       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52477     } catch (std::out_of_range& e) {
52478       {
52479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52480       };
52481     } catch (std::exception& e) {
52482       {
52483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52484       };
52485     } catch (...) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52488       };
52489     }
52490   }
52491   jresult = (int)result;
52492   return jresult;
52493 }
52494
52495
52496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52497   int jresult ;
52498   int result;
52499
52500   {
52501     try {
52502       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52503     } catch (std::out_of_range& e) {
52504       {
52505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52506       };
52507     } catch (std::exception& e) {
52508       {
52509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52510       };
52511     } catch (...) {
52512       {
52513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52514       };
52515     }
52516   }
52517   jresult = (int)result;
52518   return jresult;
52519 }
52520
52521
52522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52523   int jresult ;
52524   int result;
52525
52526   {
52527     try {
52528       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52529     } catch (std::out_of_range& e) {
52530       {
52531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52532       };
52533     } catch (std::exception& e) {
52534       {
52535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52536       };
52537     } catch (...) {
52538       {
52539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52540       };
52541     }
52542   }
52543   jresult = (int)result;
52544   return jresult;
52545 }
52546
52547
52548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52549   int jresult ;
52550   int result;
52551
52552   {
52553     try {
52554       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (...) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52566       };
52567     }
52568   }
52569   jresult = (int)result;
52570   return jresult;
52571 }
52572
52573
52574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52575   int jresult ;
52576   int result;
52577
52578   {
52579     try {
52580       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52581     } catch (std::out_of_range& e) {
52582       {
52583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52584       };
52585     } catch (std::exception& e) {
52586       {
52587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52588       };
52589     } catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52592       };
52593     }
52594   }
52595   jresult = (int)result;
52596   return jresult;
52597 }
52598
52599
52600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52601   int jresult ;
52602   int result;
52603
52604   {
52605     try {
52606       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52607     } catch (std::out_of_range& e) {
52608       {
52609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52610       };
52611     } catch (std::exception& e) {
52612       {
52613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52614       };
52615     } catch (...) {
52616       {
52617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52618       };
52619     }
52620   }
52621   jresult = (int)result;
52622   return jresult;
52623 }
52624
52625
52626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52627   int jresult ;
52628   int result;
52629
52630   {
52631     try {
52632       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52633     } catch (std::out_of_range& e) {
52634       {
52635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52636       };
52637     } catch (std::exception& e) {
52638       {
52639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52640       };
52641     } catch (...) {
52642       {
52643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52644       };
52645     }
52646   }
52647   jresult = (int)result;
52648   return jresult;
52649 }
52650
52651
52652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52653   int jresult ;
52654   int result;
52655
52656   {
52657     try {
52658       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52659     } catch (std::out_of_range& e) {
52660       {
52661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (std::exception& e) {
52664       {
52665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52666       };
52667     } catch (...) {
52668       {
52669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52670       };
52671     }
52672   }
52673   jresult = (int)result;
52674   return jresult;
52675 }
52676
52677
52678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52679   int jresult ;
52680   int result;
52681
52682   {
52683     try {
52684       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52685     } catch (std::out_of_range& e) {
52686       {
52687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52688       };
52689     } catch (std::exception& e) {
52690       {
52691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52692       };
52693     } catch (...) {
52694       {
52695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52696       };
52697     }
52698   }
52699   jresult = (int)result;
52700   return jresult;
52701 }
52702
52703
52704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52705   int jresult ;
52706   int result;
52707
52708   {
52709     try {
52710       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52711     } catch (std::out_of_range& e) {
52712       {
52713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (std::exception& e) {
52716       {
52717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52718       };
52719     } catch (...) {
52720       {
52721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52722       };
52723     }
52724   }
52725   jresult = (int)result;
52726   return jresult;
52727 }
52728
52729
52730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52731   int jresult ;
52732   int result;
52733
52734   {
52735     try {
52736       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52737     } catch (std::out_of_range& e) {
52738       {
52739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52740       };
52741     } catch (std::exception& e) {
52742       {
52743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52744       };
52745     } catch (...) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52748       };
52749     }
52750   }
52751   jresult = (int)result;
52752   return jresult;
52753 }
52754
52755
52756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52757   int jresult ;
52758   int result;
52759
52760   {
52761     try {
52762       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52770       };
52771     } catch (...) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52774       };
52775     }
52776   }
52777   jresult = (int)result;
52778   return jresult;
52779 }
52780
52781
52782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52783   int jresult ;
52784   int result;
52785
52786   {
52787     try {
52788       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52796       };
52797     } catch (...) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52800       };
52801     }
52802   }
52803   jresult = (int)result;
52804   return jresult;
52805 }
52806
52807
52808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52809   int jresult ;
52810   int result;
52811
52812   {
52813     try {
52814       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52815     } catch (std::out_of_range& e) {
52816       {
52817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52818       };
52819     } catch (std::exception& e) {
52820       {
52821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52822       };
52823     } catch (...) {
52824       {
52825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52826       };
52827     }
52828   }
52829   jresult = (int)result;
52830   return jresult;
52831 }
52832
52833
52834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52835   int jresult ;
52836   int result;
52837
52838   {
52839     try {
52840       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52841     } catch (std::out_of_range& e) {
52842       {
52843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52844       };
52845     } catch (std::exception& e) {
52846       {
52847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52848       };
52849     } catch (...) {
52850       {
52851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52852       };
52853     }
52854   }
52855   jresult = (int)result;
52856   return jresult;
52857 }
52858
52859
52860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52861   int jresult ;
52862   int result;
52863
52864   {
52865     try {
52866       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52867     } catch (std::out_of_range& e) {
52868       {
52869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52870       };
52871     } catch (std::exception& e) {
52872       {
52873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52874       };
52875     } catch (...) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52878       };
52879     }
52880   }
52881   jresult = (int)result;
52882   return jresult;
52883 }
52884
52885
52886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52887   int jresult ;
52888   int result;
52889
52890   {
52891     try {
52892       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52893     } catch (std::out_of_range& e) {
52894       {
52895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52896       };
52897     } catch (std::exception& e) {
52898       {
52899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52900       };
52901     } catch (...) {
52902       {
52903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52904       };
52905     }
52906   }
52907   jresult = (int)result;
52908   return jresult;
52909 }
52910
52911
52912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52913   int jresult ;
52914   int result;
52915
52916   {
52917     try {
52918       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52919     } catch (std::out_of_range& e) {
52920       {
52921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52922       };
52923     } catch (std::exception& e) {
52924       {
52925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52926       };
52927     } catch (...) {
52928       {
52929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52930       };
52931     }
52932   }
52933   jresult = (int)result;
52934   return jresult;
52935 }
52936
52937
52938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52939   int jresult ;
52940   int result;
52941
52942   {
52943     try {
52944       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52945     } catch (std::out_of_range& e) {
52946       {
52947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52948       };
52949     } catch (std::exception& e) {
52950       {
52951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52952       };
52953     } catch (...) {
52954       {
52955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52956       };
52957     }
52958   }
52959   jresult = (int)result;
52960   return jresult;
52961 }
52962
52963
52964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52965   int jresult ;
52966   int result;
52967
52968   {
52969     try {
52970       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52971     } catch (std::out_of_range& e) {
52972       {
52973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (std::exception& e) {
52976       {
52977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52982       };
52983     }
52984   }
52985   jresult = (int)result;
52986   return jresult;
52987 }
52988
52989
52990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
52991   int jresult ;
52992   int result;
52993
52994   {
52995     try {
52996       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
52997     } catch (std::out_of_range& e) {
52998       {
52999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (std::exception& e) {
53002       {
53003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53004       };
53005     } catch (...) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53008       };
53009     }
53010   }
53011   jresult = (int)result;
53012   return jresult;
53013 }
53014
53015
53016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
53017   int jresult ;
53018   int result;
53019
53020   {
53021     try {
53022       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
53023     } catch (std::out_of_range& e) {
53024       {
53025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53026       };
53027     } catch (std::exception& e) {
53028       {
53029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53030       };
53031     } catch (...) {
53032       {
53033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53034       };
53035     }
53036   }
53037   jresult = (int)result;
53038   return jresult;
53039 }
53040
53041
53042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53043   int jresult ;
53044   int result;
53045
53046   {
53047     try {
53048       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53049     } catch (std::out_of_range& e) {
53050       {
53051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53052       };
53053     } catch (std::exception& e) {
53054       {
53055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53056       };
53057     } catch (...) {
53058       {
53059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53060       };
53061     }
53062   }
53063   jresult = (int)result;
53064   return jresult;
53065 }
53066
53067
53068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53069   int jresult ;
53070   int result;
53071
53072   {
53073     try {
53074       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53075     } catch (std::out_of_range& e) {
53076       {
53077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53078       };
53079     } catch (std::exception& e) {
53080       {
53081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53082       };
53083     } catch (...) {
53084       {
53085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53086       };
53087     }
53088   }
53089   jresult = (int)result;
53090   return jresult;
53091 }
53092
53093
53094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53095   int jresult ;
53096   int result;
53097
53098   {
53099     try {
53100       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53108       };
53109     } catch (...) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53112       };
53113     }
53114   }
53115   jresult = (int)result;
53116   return jresult;
53117 }
53118
53119
53120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53121   int jresult ;
53122   int result;
53123
53124   {
53125     try {
53126       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53134       };
53135     } catch (...) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53138       };
53139     }
53140   }
53141   jresult = (int)result;
53142   return jresult;
53143 }
53144
53145
53146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53147   int jresult ;
53148   int result;
53149
53150   {
53151     try {
53152       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167   jresult = (int)result;
53168   return jresult;
53169 }
53170
53171
53172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53173   void * jresult ;
53174   Dali::Toolkit::Builder *result = 0 ;
53175
53176   {
53177     try {
53178       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53179     } catch (std::out_of_range& e) {
53180       {
53181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53182       };
53183     } catch (std::exception& e) {
53184       {
53185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53186       };
53187     } catch (...) {
53188       {
53189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53190       };
53191     }
53192   }
53193   jresult = (void *)result;
53194   return jresult;
53195 }
53196
53197
53198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53199   void * jresult ;
53200   Dali::Toolkit::Builder result;
53201
53202   {
53203     try {
53204       result = Dali::Toolkit::Builder::New();
53205     } catch (std::out_of_range& e) {
53206       {
53207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53208       };
53209     } catch (std::exception& e) {
53210       {
53211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (...) {
53214       {
53215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53216       };
53217     }
53218   }
53219   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53220   return jresult;
53221 }
53222
53223
53224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53225   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53226
53227   arg1 = (Dali::Toolkit::Builder *)jarg1;
53228   {
53229     try {
53230       delete arg1;
53231     } catch (std::out_of_range& e) {
53232       {
53233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53234       };
53235     } catch (std::exception& e) {
53236       {
53237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53238       };
53239     } catch (...) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53242       };
53243     }
53244   }
53245 }
53246
53247
53248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53249   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53250   std::string *arg2 = 0 ;
53251   Dali::Toolkit::Builder::UIFormat arg3 ;
53252
53253   arg1 = (Dali::Toolkit::Builder *)jarg1;
53254   if (!jarg2) {
53255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53256     return ;
53257   }
53258   std::string arg2_str(jarg2);
53259   arg2 = &arg2_str;
53260   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53261   {
53262     try {
53263       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53264     } catch (std::out_of_range& e) {
53265       {
53266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53267       };
53268     } catch (std::exception& e) {
53269       {
53270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53271       };
53272     } catch (...) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53275       };
53276     }
53277   }
53278
53279   //argout typemap for const std::string&
53280
53281 }
53282
53283
53284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53285   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53286   std::string *arg2 = 0 ;
53287
53288   arg1 = (Dali::Toolkit::Builder *)jarg1;
53289   if (!jarg2) {
53290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53291     return ;
53292   }
53293   std::string arg2_str(jarg2);
53294   arg2 = &arg2_str;
53295   {
53296     try {
53297       (arg1)->LoadFromString((std::string const &)*arg2);
53298     } catch (std::out_of_range& e) {
53299       {
53300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53301       };
53302     } catch (std::exception& e) {
53303       {
53304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53305       };
53306     } catch (...) {
53307       {
53308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53309       };
53310     }
53311   }
53312
53313   //argout typemap for const std::string&
53314
53315 }
53316
53317
53318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53319   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53320   Dali::Property::Map *arg2 = 0 ;
53321
53322   arg1 = (Dali::Toolkit::Builder *)jarg1;
53323   arg2 = (Dali::Property::Map *)jarg2;
53324   if (!arg2) {
53325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53326     return ;
53327   }
53328   {
53329     try {
53330       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53331     } catch (std::out_of_range& e) {
53332       {
53333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53334       };
53335     } catch (std::exception& e) {
53336       {
53337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53338       };
53339     } catch (...) {
53340       {
53341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53342       };
53343     }
53344   }
53345 }
53346
53347
53348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53349   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53350   std::string *arg2 = 0 ;
53351   Dali::Property::Value *arg3 = 0 ;
53352
53353   arg1 = (Dali::Toolkit::Builder *)jarg1;
53354   if (!jarg2) {
53355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53356     return ;
53357   }
53358   std::string arg2_str(jarg2);
53359   arg2 = &arg2_str;
53360   arg3 = (Dali::Property::Value *)jarg3;
53361   if (!arg3) {
53362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53363     return ;
53364   }
53365   {
53366     try {
53367       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53368     } catch (std::out_of_range& e) {
53369       {
53370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53371       };
53372     } catch (std::exception& e) {
53373       {
53374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53375       };
53376     } catch (...) {
53377       {
53378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53379       };
53380     }
53381   }
53382
53383   //argout typemap for const std::string&
53384
53385 }
53386
53387
53388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53389   void * jresult ;
53390   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53391   Dali::Property::Map *result = 0 ;
53392
53393   arg1 = (Dali::Toolkit::Builder *)jarg1;
53394   {
53395     try {
53396       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53397     } catch (std::out_of_range& e) {
53398       {
53399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53400       };
53401     } catch (std::exception& e) {
53402       {
53403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53404       };
53405     } catch (...) {
53406       {
53407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53408       };
53409     }
53410   }
53411   jresult = (void *)result;
53412   return jresult;
53413 }
53414
53415
53416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53417   void * jresult ;
53418   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53419   std::string *arg2 = 0 ;
53420   Dali::Property::Value *result = 0 ;
53421
53422   arg1 = (Dali::Toolkit::Builder *)jarg1;
53423   if (!jarg2) {
53424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53425     return 0;
53426   }
53427   std::string arg2_str(jarg2);
53428   arg2 = &arg2_str;
53429   {
53430     try {
53431       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53432     } catch (std::out_of_range& e) {
53433       {
53434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53435       };
53436     } catch (std::exception& e) {
53437       {
53438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53439       };
53440     } catch (...) {
53441       {
53442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53443       };
53444     }
53445   }
53446   jresult = (void *)result;
53447
53448   //argout typemap for const std::string&
53449
53450   return jresult;
53451 }
53452
53453
53454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53455   void * jresult ;
53456   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53457   std::string *arg2 = 0 ;
53458   Dali::Animation result;
53459
53460   arg1 = (Dali::Toolkit::Builder *)jarg1;
53461   if (!jarg2) {
53462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53463     return 0;
53464   }
53465   std::string arg2_str(jarg2);
53466   arg2 = &arg2_str;
53467   {
53468     try {
53469       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53470     } catch (std::out_of_range& e) {
53471       {
53472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53473       };
53474     } catch (std::exception& e) {
53475       {
53476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53477       };
53478     } catch (...) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53481       };
53482     }
53483   }
53484   jresult = new Dali::Animation((const Dali::Animation &)result);
53485
53486   //argout typemap for const std::string&
53487
53488   return jresult;
53489 }
53490
53491
53492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53493   void * jresult ;
53494   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53495   std::string *arg2 = 0 ;
53496   Dali::Property::Map *arg3 = 0 ;
53497   Dali::Animation result;
53498
53499   arg1 = (Dali::Toolkit::Builder *)jarg1;
53500   if (!jarg2) {
53501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53502     return 0;
53503   }
53504   std::string arg2_str(jarg2);
53505   arg2 = &arg2_str;
53506   arg3 = (Dali::Property::Map *)jarg3;
53507   if (!arg3) {
53508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53509     return 0;
53510   }
53511   {
53512     try {
53513       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53514     } catch (std::out_of_range& e) {
53515       {
53516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53517       };
53518     } catch (std::exception& e) {
53519       {
53520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53521       };
53522     } catch (...) {
53523       {
53524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53525       };
53526     }
53527   }
53528   jresult = new Dali::Animation((const Dali::Animation &)result);
53529
53530   //argout typemap for const std::string&
53531
53532   return jresult;
53533 }
53534
53535
53536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53537   void * jresult ;
53538   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53539   std::string *arg2 = 0 ;
53540   Dali::Actor arg3 ;
53541   Dali::Actor *argp3 ;
53542   Dali::Animation result;
53543
53544   arg1 = (Dali::Toolkit::Builder *)jarg1;
53545   if (!jarg2) {
53546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53547     return 0;
53548   }
53549   std::string arg2_str(jarg2);
53550   arg2 = &arg2_str;
53551   argp3 = (Dali::Actor *)jarg3;
53552   if (!argp3) {
53553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53554     return 0;
53555   }
53556   arg3 = *argp3;
53557   {
53558     try {
53559       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53560     } catch (std::out_of_range& e) {
53561       {
53562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53563       };
53564     } catch (std::exception& e) {
53565       {
53566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53567       };
53568     } catch (...) {
53569       {
53570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53571       };
53572     }
53573   }
53574   jresult = new Dali::Animation((const Dali::Animation &)result);
53575
53576   //argout typemap for const std::string&
53577
53578   return jresult;
53579 }
53580
53581
53582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53583   void * jresult ;
53584   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53585   std::string *arg2 = 0 ;
53586   Dali::Property::Map *arg3 = 0 ;
53587   Dali::Actor arg4 ;
53588   Dali::Actor *argp4 ;
53589   Dali::Animation result;
53590
53591   arg1 = (Dali::Toolkit::Builder *)jarg1;
53592   if (!jarg2) {
53593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53594     return 0;
53595   }
53596   std::string arg2_str(jarg2);
53597   arg2 = &arg2_str;
53598   arg3 = (Dali::Property::Map *)jarg3;
53599   if (!arg3) {
53600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53601     return 0;
53602   }
53603   argp4 = (Dali::Actor *)jarg4;
53604   if (!argp4) {
53605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53606     return 0;
53607   }
53608   arg4 = *argp4;
53609   {
53610     try {
53611       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53612     } catch (std::out_of_range& e) {
53613       {
53614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53615       };
53616     } catch (std::exception& e) {
53617       {
53618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53619       };
53620     } catch (...) {
53621       {
53622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53623       };
53624     }
53625   }
53626   jresult = new Dali::Animation((const Dali::Animation &)result);
53627
53628   //argout typemap for const std::string&
53629
53630   return jresult;
53631 }
53632
53633
53634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53635   void * jresult ;
53636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53637   std::string *arg2 = 0 ;
53638   Dali::BaseHandle result;
53639
53640   arg1 = (Dali::Toolkit::Builder *)jarg1;
53641   if (!jarg2) {
53642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53643     return 0;
53644   }
53645   std::string arg2_str(jarg2);
53646   arg2 = &arg2_str;
53647   {
53648     try {
53649       result = (arg1)->Create((std::string const &)*arg2);
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53661       };
53662     }
53663   }
53664   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53665
53666   //argout typemap for const std::string&
53667
53668   return jresult;
53669 }
53670
53671
53672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53673   void * jresult ;
53674   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53675   std::string *arg2 = 0 ;
53676   Dali::Property::Map *arg3 = 0 ;
53677   Dali::BaseHandle result;
53678
53679   arg1 = (Dali::Toolkit::Builder *)jarg1;
53680   if (!jarg2) {
53681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53682     return 0;
53683   }
53684   std::string arg2_str(jarg2);
53685   arg2 = &arg2_str;
53686   arg3 = (Dali::Property::Map *)jarg3;
53687   if (!arg3) {
53688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53689     return 0;
53690   }
53691   {
53692     try {
53693       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53694     } catch (std::out_of_range& e) {
53695       {
53696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53697       };
53698     } catch (std::exception& e) {
53699       {
53700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53701       };
53702     } catch (...) {
53703       {
53704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53705       };
53706     }
53707   }
53708   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53709
53710   //argout typemap for const std::string&
53711
53712   return jresult;
53713 }
53714
53715
53716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53717   void * jresult ;
53718   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53719   std::string *arg2 = 0 ;
53720   Dali::BaseHandle result;
53721
53722   arg1 = (Dali::Toolkit::Builder *)jarg1;
53723   if (!jarg2) {
53724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53725     return 0;
53726   }
53727   std::string arg2_str(jarg2);
53728   arg2 = &arg2_str;
53729   {
53730     try {
53731       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53739       };
53740     } catch (...) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53743       };
53744     }
53745   }
53746   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53747
53748   //argout typemap for const std::string&
53749
53750   return jresult;
53751 }
53752
53753
53754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53755   unsigned int jresult ;
53756   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53757   std::string *arg2 = 0 ;
53758   Dali::Handle *arg3 = 0 ;
53759   bool result;
53760
53761   arg1 = (Dali::Toolkit::Builder *)jarg1;
53762   if (!jarg2) {
53763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53764     return 0;
53765   }
53766   std::string arg2_str(jarg2);
53767   arg2 = &arg2_str;
53768   arg3 = (Dali::Handle *)jarg3;
53769   if (!arg3) {
53770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53771     return 0;
53772   }
53773   {
53774     try {
53775       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (...) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53787       };
53788     }
53789   }
53790   jresult = result;
53791
53792   //argout typemap for const std::string&
53793
53794   return jresult;
53795 }
53796
53797
53798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53799   unsigned int jresult ;
53800   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53801   Dali::Handle *arg2 = 0 ;
53802   std::string *arg3 = 0 ;
53803   bool result;
53804
53805   arg1 = (Dali::Toolkit::Builder *)jarg1;
53806   arg2 = (Dali::Handle *)jarg2;
53807   if (!arg2) {
53808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53809     return 0;
53810   }
53811   if (!jarg3) {
53812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53813     return 0;
53814   }
53815   std::string arg3_str(jarg3);
53816   arg3 = &arg3_str;
53817   {
53818     try {
53819       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53820     } catch (std::out_of_range& e) {
53821       {
53822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53823       };
53824     } catch (std::exception& e) {
53825       {
53826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53827       };
53828     } catch (...) {
53829       {
53830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53831       };
53832     }
53833   }
53834   jresult = result;
53835
53836   //argout typemap for const std::string&
53837
53838   return jresult;
53839 }
53840
53841
53842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53843   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53844   Dali::Actor arg2 ;
53845   Dali::Actor *argp2 ;
53846
53847   arg1 = (Dali::Toolkit::Builder *)jarg1;
53848   argp2 = (Dali::Actor *)jarg2;
53849   if (!argp2) {
53850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53851     return ;
53852   }
53853   arg2 = *argp2;
53854   {
53855     try {
53856       (arg1)->AddActors(arg2);
53857     } catch (std::out_of_range& e) {
53858       {
53859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53860       };
53861     } catch (std::exception& e) {
53862       {
53863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53864       };
53865     } catch (...) {
53866       {
53867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53868       };
53869     }
53870   }
53871 }
53872
53873
53874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53875   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53876   std::string *arg2 = 0 ;
53877   Dali::Actor arg3 ;
53878   Dali::Actor *argp3 ;
53879
53880   arg1 = (Dali::Toolkit::Builder *)jarg1;
53881   if (!jarg2) {
53882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53883     return ;
53884   }
53885   std::string arg2_str(jarg2);
53886   arg2 = &arg2_str;
53887   argp3 = (Dali::Actor *)jarg3;
53888   if (!argp3) {
53889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53890     return ;
53891   }
53892   arg3 = *argp3;
53893   {
53894     try {
53895       (arg1)->AddActors((std::string const &)*arg2,arg3);
53896     } catch (std::out_of_range& e) {
53897       {
53898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53899       };
53900     } catch (std::exception& e) {
53901       {
53902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53903       };
53904     } catch (...) {
53905       {
53906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53907       };
53908     }
53909   }
53910
53911   //argout typemap for const std::string&
53912
53913 }
53914
53915
53916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53917   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53918   std::string *arg2 = 0 ;
53919
53920   arg1 = (Dali::Toolkit::Builder *)jarg1;
53921   if (!jarg2) {
53922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53923     return ;
53924   }
53925   std::string arg2_str(jarg2);
53926   arg2 = &arg2_str;
53927   {
53928     try {
53929       (arg1)->CreateRenderTask((std::string const &)*arg2);
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53937       };
53938     } catch (...) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53941       };
53942     }
53943   }
53944
53945   //argout typemap for const std::string&
53946
53947 }
53948
53949
53950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53951   void * jresult ;
53952   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53953   std::string *arg2 = 0 ;
53954   Dali::FrameBufferImage result;
53955
53956   arg1 = (Dali::Toolkit::Builder *)jarg1;
53957   if (!jarg2) {
53958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53959     return 0;
53960   }
53961   std::string arg2_str(jarg2);
53962   arg2 = &arg2_str;
53963   {
53964     try {
53965       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53966     } catch (std::out_of_range& e) {
53967       {
53968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53969       };
53970     } catch (std::exception& e) {
53971       {
53972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53977       };
53978     }
53979   }
53980   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
53981
53982   //argout typemap for const std::string&
53983
53984   return jresult;
53985 }
53986
53987
53988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
53989   void * jresult ;
53990   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53991   std::string *arg2 = 0 ;
53992   Dali::Path result;
53993
53994   arg1 = (Dali::Toolkit::Builder *)jarg1;
53995   if (!jarg2) {
53996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53997     return 0;
53998   }
53999   std::string arg2_str(jarg2);
54000   arg2 = &arg2_str;
54001   {
54002     try {
54003       result = (arg1)->GetPath((std::string const &)*arg2);
54004     } catch (std::out_of_range& e) {
54005       {
54006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54007       };
54008     } catch (std::exception& e) {
54009       {
54010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54011       };
54012     } catch (...) {
54013       {
54014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54015       };
54016     }
54017   }
54018   jresult = new Dali::Path((const Dali::Path &)result);
54019
54020   //argout typemap for const std::string&
54021
54022   return jresult;
54023 }
54024
54025
54026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54027   void * jresult ;
54028   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54029   std::string *arg2 = 0 ;
54030   Dali::PathConstrainer result;
54031
54032   arg1 = (Dali::Toolkit::Builder *)jarg1;
54033   if (!jarg2) {
54034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54035     return 0;
54036   }
54037   std::string arg2_str(jarg2);
54038   arg2 = &arg2_str;
54039   {
54040     try {
54041       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54042     } catch (std::out_of_range& e) {
54043       {
54044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54045       };
54046     } catch (std::exception& e) {
54047       {
54048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54049       };
54050     } catch (...) {
54051       {
54052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54053       };
54054     }
54055   }
54056   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54057
54058   //argout typemap for const std::string&
54059
54060   return jresult;
54061 }
54062
54063
54064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54065   void * jresult ;
54066   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54067   std::string *arg2 = 0 ;
54068   Dali::LinearConstrainer result;
54069
54070   arg1 = (Dali::Toolkit::Builder *)jarg1;
54071   if (!jarg2) {
54072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54073     return 0;
54074   }
54075   std::string arg2_str(jarg2);
54076   arg2 = &arg2_str;
54077   {
54078     try {
54079       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54080     } catch (std::out_of_range& e) {
54081       {
54082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54083       };
54084     } catch (std::exception& e) {
54085       {
54086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54087       };
54088     } catch (...) {
54089       {
54090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54091       };
54092     }
54093   }
54094   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54095
54096   //argout typemap for const std::string&
54097
54098   return jresult;
54099 }
54100
54101
54102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54103   void * jresult ;
54104   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54105   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54106
54107   arg1 = (Dali::Toolkit::Builder *)jarg1;
54108   {
54109     try {
54110       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54111     } catch (std::out_of_range& e) {
54112       {
54113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54114       };
54115     } catch (std::exception& e) {
54116       {
54117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (...) {
54120       {
54121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54122       };
54123     }
54124   }
54125   jresult = (void *)result;
54126   return jresult;
54127 }
54128
54129
54130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54131   void * jresult ;
54132   Dali::Toolkit::TransitionData *result = 0 ;
54133
54134   {
54135     try {
54136       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54137     } catch (std::out_of_range& e) {
54138       {
54139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54140       };
54141     } catch (std::exception& e) {
54142       {
54143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54144       };
54145     } catch (...) {
54146       {
54147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54148       };
54149     }
54150   }
54151   jresult = (void *)result;
54152   return jresult;
54153 }
54154
54155
54156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54157   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54158
54159   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54160   {
54161     try {
54162       delete arg1;
54163     } catch (std::out_of_range& e) {
54164       {
54165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54166       };
54167     } catch (std::exception& e) {
54168       {
54169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54170       };
54171     } catch (...) {
54172       {
54173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54174       };
54175     }
54176   }
54177 }
54178
54179
54180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54181   void * jresult ;
54182   Dali::Property::Map *arg1 = 0 ;
54183   Dali::Toolkit::TransitionData result;
54184
54185   arg1 = (Dali::Property::Map *)jarg1;
54186   if (!arg1) {
54187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54188     return 0;
54189   }
54190   {
54191     try {
54192       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54200       };
54201     } catch (...) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54204       };
54205     }
54206   }
54207   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54208   return jresult;
54209 }
54210
54211
54212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54213   void * jresult ;
54214   Dali::Property::Array *arg1 = 0 ;
54215   Dali::Toolkit::TransitionData result;
54216
54217   arg1 = (Dali::Property::Array *)jarg1;
54218   if (!arg1) {
54219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54220     return 0;
54221   }
54222   {
54223     try {
54224       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54225     } catch (std::out_of_range& e) {
54226       {
54227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54228       };
54229     } catch (std::exception& e) {
54230       {
54231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54232       };
54233     } catch (...) {
54234       {
54235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54236       };
54237     }
54238   }
54239   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54240   return jresult;
54241 }
54242
54243
54244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54245   void * jresult ;
54246   Dali::BaseHandle arg1 ;
54247   Dali::BaseHandle *argp1 ;
54248   Dali::Toolkit::TransitionData result;
54249
54250   argp1 = (Dali::BaseHandle *)jarg1;
54251   if (!argp1) {
54252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54253     return 0;
54254   }
54255   arg1 = *argp1;
54256   {
54257     try {
54258       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54259     } catch (std::out_of_range& e) {
54260       {
54261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (std::exception& e) {
54264       {
54265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54266       };
54267     } catch (...) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54270       };
54271     }
54272   }
54273   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54274   return jresult;
54275 }
54276
54277
54278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54279   void * jresult ;
54280   Dali::Toolkit::TransitionData *arg1 = 0 ;
54281   Dali::Toolkit::TransitionData *result = 0 ;
54282
54283   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54284   if (!arg1) {
54285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54286     return 0;
54287   }
54288   {
54289     try {
54290       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54291     } catch (std::out_of_range& e) {
54292       {
54293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54294       };
54295     } catch (std::exception& e) {
54296       {
54297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54298       };
54299     } catch (...) {
54300       {
54301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54302       };
54303     }
54304   }
54305   jresult = (void *)result;
54306   return jresult;
54307 }
54308
54309
54310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54311   void * jresult ;
54312   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54313   Dali::Toolkit::TransitionData *arg2 = 0 ;
54314   Dali::Toolkit::TransitionData *result = 0 ;
54315
54316   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54317   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54318   if (!arg2) {
54319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54320     return 0;
54321   }
54322   {
54323     try {
54324       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54325     } catch (std::out_of_range& e) {
54326       {
54327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54328       };
54329     } catch (std::exception& e) {
54330       {
54331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54332       };
54333     } catch (...) {
54334       {
54335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54336       };
54337     }
54338   }
54339   jresult = (void *)result;
54340   return jresult;
54341 }
54342
54343
54344 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54345   unsigned long jresult ;
54346   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54347   size_t result;
54348
54349   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54350   {
54351     try {
54352       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54353     } catch (std::out_of_range& e) {
54354       {
54355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54356       };
54357     } catch (std::exception& e) {
54358       {
54359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54360       };
54361     } catch (...) {
54362       {
54363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54364       };
54365     }
54366   }
54367   jresult = (unsigned long)result;
54368   return jresult;
54369 }
54370
54371
54372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54373   void * jresult ;
54374   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54375   size_t arg2 ;
54376   Dali::Property::Map result;
54377
54378   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54379   arg2 = (size_t)jarg2;
54380   {
54381     try {
54382       result = (arg1)->GetAnimatorAt(arg2);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54390       };
54391     } catch (...) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54394       };
54395     }
54396   }
54397   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54398   return jresult;
54399 }
54400
54401
54402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54403   void * jresult ;
54404   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54405   Dali::Toolkit::TransitionData *result = 0 ;
54406
54407   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54408   {
54409     try {
54410       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54411     } catch (std::out_of_range& e) {
54412       {
54413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54414       };
54415     } catch (std::exception& e) {
54416       {
54417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54418       };
54419     } catch (...) {
54420       {
54421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54422       };
54423     }
54424   }
54425   jresult = (void *)result;
54426   return jresult;
54427 }
54428
54429
54430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54431   int jresult ;
54432   int result;
54433
54434   {
54435     try {
54436       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54437     } catch (std::out_of_range& e) {
54438       {
54439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54440       };
54441     } catch (std::exception& e) {
54442       {
54443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54444       };
54445     } catch (...) {
54446       {
54447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54448       };
54449     }
54450   }
54451   jresult = (int)result;
54452   return jresult;
54453 }
54454
54455
54456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54457   int jresult ;
54458   int result;
54459
54460   {
54461     try {
54462       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54463     } catch (std::out_of_range& e) {
54464       {
54465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54466       };
54467     } catch (std::exception& e) {
54468       {
54469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54470       };
54471     } catch (...) {
54472       {
54473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54474       };
54475     }
54476   }
54477   jresult = (int)result;
54478   return jresult;
54479 }
54480
54481
54482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54483   int jresult ;
54484   int result;
54485
54486   {
54487     try {
54488       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54489     } catch (std::out_of_range& e) {
54490       {
54491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54492       };
54493     } catch (std::exception& e) {
54494       {
54495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54496       };
54497     } catch (...) {
54498       {
54499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54500       };
54501     }
54502   }
54503   jresult = (int)result;
54504   return jresult;
54505 }
54506
54507
54508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54509   int jresult ;
54510   int result;
54511
54512   {
54513     try {
54514       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54515     } catch (std::out_of_range& e) {
54516       {
54517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (std::exception& e) {
54520       {
54521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54522       };
54523     } catch (...) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54526       };
54527     }
54528   }
54529   jresult = (int)result;
54530   return jresult;
54531 }
54532
54533
54534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54535   int jresult ;
54536   int result;
54537
54538   {
54539     try {
54540       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54541     } catch (std::out_of_range& e) {
54542       {
54543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54544       };
54545     } catch (std::exception& e) {
54546       {
54547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54548       };
54549     } catch (...) {
54550       {
54551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54552       };
54553     }
54554   }
54555   jresult = (int)result;
54556   return jresult;
54557 }
54558
54559
54560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54561   int jresult ;
54562   int result;
54563
54564   {
54565     try {
54566       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54567     } catch (std::out_of_range& e) {
54568       {
54569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54570       };
54571     } catch (std::exception& e) {
54572       {
54573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54574       };
54575     } catch (...) {
54576       {
54577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54578       };
54579     }
54580   }
54581   jresult = (int)result;
54582   return jresult;
54583 }
54584
54585
54586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54587   int jresult ;
54588   int result;
54589
54590   {
54591     try {
54592       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54600       };
54601     } catch (...) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54604       };
54605     }
54606   }
54607   jresult = (int)result;
54608   return jresult;
54609 }
54610
54611
54612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54613   int jresult ;
54614   int result;
54615
54616   {
54617     try {
54618       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54619     } catch (std::out_of_range& e) {
54620       {
54621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54622       };
54623     } catch (std::exception& e) {
54624       {
54625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54626       };
54627     } catch (...) {
54628       {
54629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54630       };
54631     }
54632   }
54633   jresult = (int)result;
54634   return jresult;
54635 }
54636
54637
54638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54639   int jresult ;
54640   int result;
54641
54642   {
54643     try {
54644       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54645     } catch (std::out_of_range& e) {
54646       {
54647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54648       };
54649     } catch (std::exception& e) {
54650       {
54651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54652       };
54653     } catch (...) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54656       };
54657     }
54658   }
54659   jresult = (int)result;
54660   return jresult;
54661 }
54662
54663
54664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54665   int jresult ;
54666   int result;
54667
54668   {
54669     try {
54670       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54671     } catch (std::out_of_range& e) {
54672       {
54673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54674       };
54675     } catch (std::exception& e) {
54676       {
54677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54678       };
54679     } catch (...) {
54680       {
54681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54682       };
54683     }
54684   }
54685   jresult = (int)result;
54686   return jresult;
54687 }
54688
54689
54690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54691   int jresult ;
54692   int result;
54693
54694   {
54695     try {
54696       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (...) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54708       };
54709     }
54710   }
54711   jresult = (int)result;
54712   return jresult;
54713 }
54714
54715
54716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54717   int jresult ;
54718   int result;
54719
54720   {
54721     try {
54722       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54723     } catch (std::out_of_range& e) {
54724       {
54725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54726       };
54727     } catch (std::exception& e) {
54728       {
54729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54730       };
54731     } catch (...) {
54732       {
54733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54734       };
54735     }
54736   }
54737   jresult = (int)result;
54738   return jresult;
54739 }
54740
54741
54742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54743   int jresult ;
54744   int result;
54745
54746   {
54747     try {
54748       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54749     } catch (std::out_of_range& e) {
54750       {
54751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54752       };
54753     } catch (std::exception& e) {
54754       {
54755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54756       };
54757     } catch (...) {
54758       {
54759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54760       };
54761     }
54762   }
54763   jresult = (int)result;
54764   return jresult;
54765 }
54766
54767
54768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54769   int jresult ;
54770   int result;
54771
54772   {
54773     try {
54774       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54775     } catch (std::out_of_range& e) {
54776       {
54777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54778       };
54779     } catch (std::exception& e) {
54780       {
54781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54782       };
54783     } catch (...) {
54784       {
54785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54786       };
54787     }
54788   }
54789   jresult = (int)result;
54790   return jresult;
54791 }
54792
54793
54794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54795   void * jresult ;
54796   Dali::Toolkit::Control result;
54797
54798   {
54799     try {
54800       result = Dali::Toolkit::Internal::Control::New();
54801     } catch (std::out_of_range& e) {
54802       {
54803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54804       };
54805     } catch (std::exception& e) {
54806       {
54807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54808       };
54809     } catch (...) {
54810       {
54811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54812       };
54813     }
54814   }
54815   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54816   return jresult;
54817 }
54818
54819
54820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54822   std::string *arg2 = 0 ;
54823
54824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54825   if (!jarg2) {
54826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54827     return ;
54828   }
54829   std::string arg2_str(jarg2);
54830   arg2 = &arg2_str;
54831   {
54832     try {
54833       (arg1)->SetStyleName((std::string const &)*arg2);
54834     } catch (std::out_of_range& e) {
54835       {
54836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54837       };
54838     } catch (std::exception& e) {
54839       {
54840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54841       };
54842     } catch (...) {
54843       {
54844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54845       };
54846     }
54847   }
54848
54849   //argout typemap for const std::string&
54850
54851 }
54852
54853
54854 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54855   char * jresult ;
54856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54857   std::string *result = 0 ;
54858
54859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54860   {
54861     try {
54862       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
54863     } catch (std::out_of_range& e) {
54864       {
54865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54866       };
54867     } catch (std::exception& e) {
54868       {
54869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54870       };
54871     } catch (...) {
54872       {
54873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54874       };
54875     }
54876   }
54877   jresult = SWIG_csharp_string_callback(result->c_str());
54878   return jresult;
54879 }
54880
54881
54882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54884   Dali::Vector4 *arg2 = 0 ;
54885
54886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54887   arg2 = (Dali::Vector4 *)jarg2;
54888   if (!arg2) {
54889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54890     return ;
54891   }
54892   {
54893     try {
54894       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54902       };
54903     } catch (...) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54906       };
54907     }
54908   }
54909 }
54910
54911
54912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54913   void * jresult ;
54914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54915   Dali::Vector4 result;
54916
54917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54918   {
54919     try {
54920       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54921     } catch (std::out_of_range& e) {
54922       {
54923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54924       };
54925     } catch (std::exception& e) {
54926       {
54927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54928       };
54929     } catch (...) {
54930       {
54931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54932       };
54933     }
54934   }
54935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54936   return jresult;
54937 }
54938
54939
54940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54942   Dali::Image arg2 ;
54943   Dali::Image *argp2 ;
54944
54945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54946   argp2 = (Dali::Image *)jarg2;
54947   if (!argp2) {
54948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54949     return ;
54950   }
54951   arg2 = *argp2;
54952   {
54953     try {
54954       (arg1)->SetBackgroundImage(arg2);
54955     } catch (std::out_of_range& e) {
54956       {
54957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54958       };
54959     } catch (std::exception& e) {
54960       {
54961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54962       };
54963     } catch (...) {
54964       {
54965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54966       };
54967     }
54968   }
54969 }
54970
54971
54972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54974   Dali::Property::Map *arg2 = 0 ;
54975
54976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54977   arg2 = (Dali::Property::Map *)jarg2;
54978   if (!arg2) {
54979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54980     return ;
54981   }
54982   {
54983     try {
54984       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
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_ClearBackground(void * jarg1) {
55003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55004
55005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55006   {
55007     try {
55008       (arg1)->ClearBackground();
55009     } catch (std::out_of_range& e) {
55010       {
55011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (std::exception& e) {
55014       {
55015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55016       };
55017     } catch (...) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55020       };
55021     }
55022   }
55023 }
55024
55025
55026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55028   Dali::Gesture::Type arg2 ;
55029
55030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55031   arg2 = (Dali::Gesture::Type)jarg2;
55032   {
55033     try {
55034       (arg1)->EnableGestureDetection(arg2);
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55042       };
55043     } catch (...) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55046       };
55047     }
55048   }
55049 }
55050
55051
55052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55054   Dali::Gesture::Type arg2 ;
55055
55056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55057   arg2 = (Dali::Gesture::Type)jarg2;
55058   {
55059     try {
55060       (arg1)->DisableGestureDetection(arg2);
55061     } catch (std::out_of_range& e) {
55062       {
55063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55064       };
55065     } catch (std::exception& e) {
55066       {
55067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55068       };
55069     } catch (...) {
55070       {
55071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55072       };
55073     }
55074   }
55075 }
55076
55077
55078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55079   void * jresult ;
55080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55081   Dali::PinchGestureDetector result;
55082
55083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55084   {
55085     try {
55086       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55102   return jresult;
55103 }
55104
55105
55106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55107   void * jresult ;
55108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55109   Dali::PanGestureDetector result;
55110
55111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55112   {
55113     try {
55114       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55115     } catch (std::out_of_range& e) {
55116       {
55117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55118       };
55119     } catch (std::exception& e) {
55120       {
55121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55122       };
55123     } catch (...) {
55124       {
55125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55126       };
55127     }
55128   }
55129   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55130   return jresult;
55131 }
55132
55133
55134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55135   void * jresult ;
55136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55137   Dali::TapGestureDetector result;
55138
55139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55140   {
55141     try {
55142       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55143     } catch (std::out_of_range& e) {
55144       {
55145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55146       };
55147     } catch (std::exception& e) {
55148       {
55149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (...) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55154       };
55155     }
55156   }
55157   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55158   return jresult;
55159 }
55160
55161
55162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55163   void * jresult ;
55164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55165   Dali::LongPressGestureDetector result;
55166
55167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55168   {
55169     try {
55170       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55171     } catch (std::out_of_range& e) {
55172       {
55173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55174       };
55175     } catch (std::exception& e) {
55176       {
55177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55178       };
55179     } catch (...) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55182       };
55183     }
55184   }
55185   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55186   return jresult;
55187 }
55188
55189
55190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55192   bool arg2 ;
55193
55194   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55195   arg2 = jarg2 ? true : false;
55196   {
55197     try {
55198       (arg1)->SetKeyboardNavigationSupport(arg2);
55199     } catch (std::out_of_range& e) {
55200       {
55201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55202       };
55203     } catch (std::exception& e) {
55204       {
55205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55206       };
55207     } catch (...) {
55208       {
55209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55210       };
55211     }
55212   }
55213 }
55214
55215
55216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55217   unsigned int jresult ;
55218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55219   bool result;
55220
55221   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55222   {
55223     try {
55224       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55225     } catch (std::out_of_range& e) {
55226       {
55227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55228       };
55229     } catch (std::exception& e) {
55230       {
55231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55232       };
55233     } catch (...) {
55234       {
55235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55236       };
55237     }
55238   }
55239   jresult = result;
55240   return jresult;
55241 }
55242
55243
55244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55246
55247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55248   {
55249     try {
55250       (arg1)->SetKeyInputFocus();
55251     } catch (std::out_of_range& e) {
55252       {
55253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55254       };
55255     } catch (std::exception& e) {
55256       {
55257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55258       };
55259     } catch (...) {
55260       {
55261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55262       };
55263     }
55264   }
55265 }
55266
55267
55268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55269   unsigned int jresult ;
55270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55271   bool result;
55272
55273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55274   {
55275     try {
55276       result = (bool)(arg1)->HasKeyInputFocus();
55277     } catch (std::out_of_range& e) {
55278       {
55279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55280       };
55281     } catch (std::exception& e) {
55282       {
55283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55284       };
55285     } catch (...) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55288       };
55289     }
55290   }
55291   jresult = result;
55292   return jresult;
55293 }
55294
55295
55296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55298
55299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55300   {
55301     try {
55302       (arg1)->ClearKeyInputFocus();
55303     } catch (std::out_of_range& e) {
55304       {
55305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55306       };
55307     } catch (std::exception& e) {
55308       {
55309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55310       };
55311     } catch (...) {
55312       {
55313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55314       };
55315     }
55316   }
55317 }
55318
55319
55320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55322   bool arg2 ;
55323
55324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55325   arg2 = jarg2 ? true : false;
55326   {
55327     try {
55328       (arg1)->SetAsKeyboardFocusGroup(arg2);
55329     } catch (std::out_of_range& e) {
55330       {
55331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55332       };
55333     } catch (std::exception& e) {
55334       {
55335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55336       };
55337     } catch (...) {
55338       {
55339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55340       };
55341     }
55342   }
55343 }
55344
55345
55346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55347   unsigned int jresult ;
55348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55349   bool result;
55350
55351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55352   {
55353     try {
55354       result = (bool)(arg1)->IsKeyboardFocusGroup();
55355     } catch (std::out_of_range& e) {
55356       {
55357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55358       };
55359     } catch (std::exception& e) {
55360       {
55361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55362       };
55363     } catch (...) {
55364       {
55365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55366       };
55367     }
55368   }
55369   jresult = result;
55370   return jresult;
55371 }
55372
55373
55374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(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)->AccessibilityActivate();
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_KeyboardEnter(void * jarg1) {
55399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55400
55401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55402   {
55403     try {
55404       (arg1)->KeyboardEnter();
55405     } catch (std::out_of_range& e) {
55406       {
55407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (std::exception& e) {
55410       {
55411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55412       };
55413     } catch (...) {
55414       {
55415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55416       };
55417     }
55418   }
55419 }
55420
55421
55422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55423   void * jresult ;
55424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55425   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55426
55427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55428   {
55429     try {
55430       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55431     } catch (std::out_of_range& e) {
55432       {
55433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55434       };
55435     } catch (std::exception& e) {
55436       {
55437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (...) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55442       };
55443     }
55444   }
55445   jresult = (void *)result;
55446   return jresult;
55447 }
55448
55449
55450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55451   void * jresult ;
55452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55453   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55454
55455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55456   {
55457     try {
55458       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55459     } catch (std::out_of_range& e) {
55460       {
55461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55462       };
55463     } catch (std::exception& e) {
55464       {
55465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (...) {
55468       {
55469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55470       };
55471     }
55472   }
55473   jresult = (void *)result;
55474   return jresult;
55475 }
55476
55477
55478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55479   void * jresult ;
55480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55481   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55482
55483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55484   {
55485     try {
55486       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55487     } catch (std::out_of_range& e) {
55488       {
55489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55490       };
55491     } catch (std::exception& e) {
55492       {
55493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55494       };
55495     } catch (...) {
55496       {
55497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55498       };
55499     }
55500   }
55501   jresult = (void *)result;
55502   return jresult;
55503 }
55504
55505
55506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55507   unsigned int jresult ;
55508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55509   Dali::KeyEvent *arg2 = 0 ;
55510   bool result;
55511
55512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55513   arg2 = (Dali::KeyEvent *)jarg2;
55514   if (!arg2) {
55515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55516     return 0;
55517   }
55518   {
55519     try {
55520       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55521     } catch (std::out_of_range& e) {
55522       {
55523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55524       };
55525     } catch (std::exception& e) {
55526       {
55527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55528       };
55529     } catch (...) {
55530       {
55531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55532       };
55533     }
55534   }
55535   jresult = result;
55536   return jresult;
55537 }
55538
55539
55540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55542   int arg2 ;
55543   SwigDirector_ViewImpl *darg = 0;
55544
55545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55546   arg2 = (int)jarg2;
55547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55548   {
55549     try {
55550       (darg)->OnStageConnection(arg2);
55551     } catch (std::out_of_range& e) {
55552       {
55553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55554       };
55555     } catch (std::exception& e) {
55556       {
55557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55558       };
55559     } catch (...) {
55560       {
55561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55562       };
55563     }
55564   }
55565 }
55566
55567
55568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55570   int arg2 ;
55571   SwigDirector_ViewImpl *darg = 0;
55572
55573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55574   arg2 = (int)jarg2;
55575   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55576   {
55577     try {
55578       (darg)->OnStageConnectionSwigPublic(arg2);
55579     } catch (std::out_of_range& e) {
55580       {
55581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55582       };
55583     } catch (std::exception& e) {
55584       {
55585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55586       };
55587     } catch (...) {
55588       {
55589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55590       };
55591     }
55592   }
55593 }
55594
55595
55596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55598   SwigDirector_ViewImpl *darg = 0;
55599
55600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55602   {
55603     try {
55604       (darg)->OnStageDisconnection();
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55612       };
55613     } catch (...) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55616       };
55617     }
55618   }
55619 }
55620
55621
55622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55624   SwigDirector_ViewImpl *darg = 0;
55625
55626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55627   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55628   {
55629     try {
55630       (darg)->OnStageDisconnectionSwigPublic();
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55638       };
55639     } catch (...) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55642       };
55643     }
55644   }
55645 }
55646
55647
55648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55650   Dali::Actor *arg2 = 0 ;
55651   SwigDirector_ViewImpl *darg = 0;
55652
55653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55654   arg2 = (Dali::Actor *)jarg2;
55655   if (!arg2) {
55656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55657     return ;
55658   }
55659   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55660   {
55661     try {
55662       (darg)->OnChildAdd(*arg2);
55663     } catch (std::out_of_range& e) {
55664       {
55665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55666       };
55667     } catch (std::exception& e) {
55668       {
55669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55670       };
55671     } catch (...) {
55672       {
55673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55674       };
55675     }
55676   }
55677 }
55678
55679
55680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55682   Dali::Actor *arg2 = 0 ;
55683   SwigDirector_ViewImpl *darg = 0;
55684
55685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55686   arg2 = (Dali::Actor *)jarg2;
55687   if (!arg2) {
55688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55689     return ;
55690   }
55691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55692   {
55693     try {
55694       (darg)->OnChildAddSwigPublic(*arg2);
55695     } catch (std::out_of_range& e) {
55696       {
55697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55698       };
55699     } catch (std::exception& e) {
55700       {
55701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55702       };
55703     } catch (...) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55706       };
55707     }
55708   }
55709 }
55710
55711
55712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55714   Dali::Actor *arg2 = 0 ;
55715   SwigDirector_ViewImpl *darg = 0;
55716
55717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55718   arg2 = (Dali::Actor *)jarg2;
55719   if (!arg2) {
55720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55721     return ;
55722   }
55723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55724   {
55725     try {
55726       (darg)->OnChildRemove(*arg2);
55727     } catch (std::out_of_range& e) {
55728       {
55729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55730       };
55731     } catch (std::exception& e) {
55732       {
55733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55734       };
55735     } catch (...) {
55736       {
55737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55738       };
55739     }
55740   }
55741 }
55742
55743
55744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55746   Dali::Actor *arg2 = 0 ;
55747   SwigDirector_ViewImpl *darg = 0;
55748
55749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55750   arg2 = (Dali::Actor *)jarg2;
55751   if (!arg2) {
55752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55753     return ;
55754   }
55755   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55756   {
55757     try {
55758       (darg)->OnChildRemoveSwigPublic(*arg2);
55759     } catch (std::out_of_range& e) {
55760       {
55761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55762       };
55763     } catch (std::exception& e) {
55764       {
55765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55766       };
55767     } catch (...) {
55768       {
55769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55770       };
55771     }
55772   }
55773 }
55774
55775
55776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55778   Dali::Property::Index arg2 ;
55779   Dali::Property::Value arg3 ;
55780   Dali::Property::Value *argp3 ;
55781   SwigDirector_ViewImpl *darg = 0;
55782
55783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55784   arg2 = (Dali::Property::Index)jarg2;
55785   argp3 = (Dali::Property::Value *)jarg3;
55786   if (!argp3) {
55787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55788     return ;
55789   }
55790   arg3 = *argp3;
55791   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55792   {
55793     try {
55794       (darg)->OnPropertySet(arg2,arg3);
55795     } catch (std::out_of_range& e) {
55796       {
55797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55798       };
55799     } catch (std::exception& e) {
55800       {
55801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55802       };
55803     } catch (...) {
55804       {
55805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55806       };
55807     }
55808   }
55809 }
55810
55811
55812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55814   Dali::Property::Index arg2 ;
55815   Dali::Property::Value arg3 ;
55816   Dali::Property::Value *argp3 ;
55817   SwigDirector_ViewImpl *darg = 0;
55818
55819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55820   arg2 = (Dali::Property::Index)jarg2;
55821   argp3 = (Dali::Property::Value *)jarg3;
55822   if (!argp3) {
55823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55824     return ;
55825   }
55826   arg3 = *argp3;
55827   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55828   {
55829     try {
55830       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55831     } catch (std::out_of_range& e) {
55832       {
55833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55834       };
55835     } catch (std::exception& e) {
55836       {
55837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55838       };
55839     } catch (...) {
55840       {
55841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55842       };
55843     }
55844   }
55845 }
55846
55847
55848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55850   Dali::Vector3 *arg2 = 0 ;
55851   SwigDirector_ViewImpl *darg = 0;
55852
55853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55854   arg2 = (Dali::Vector3 *)jarg2;
55855   if (!arg2) {
55856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55857     return ;
55858   }
55859   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55860   {
55861     try {
55862       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55863     } catch (std::out_of_range& e) {
55864       {
55865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55866       };
55867     } catch (std::exception& e) {
55868       {
55869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55870       };
55871     } catch (...) {
55872       {
55873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55874       };
55875     }
55876   }
55877 }
55878
55879
55880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55882   Dali::Vector3 *arg2 = 0 ;
55883   SwigDirector_ViewImpl *darg = 0;
55884
55885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55886   arg2 = (Dali::Vector3 *)jarg2;
55887   if (!arg2) {
55888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55889     return ;
55890   }
55891   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55892   {
55893     try {
55894       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55895     } catch (std::out_of_range& e) {
55896       {
55897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55898       };
55899     } catch (std::exception& e) {
55900       {
55901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55902       };
55903     } catch (...) {
55904       {
55905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55906       };
55907     }
55908   }
55909 }
55910
55911
55912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55914   Dali::Animation *arg2 = 0 ;
55915   Dali::Vector3 *arg3 = 0 ;
55916   SwigDirector_ViewImpl *darg = 0;
55917
55918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55919   arg2 = (Dali::Animation *)jarg2;
55920   if (!arg2) {
55921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55922     return ;
55923   }
55924   arg3 = (Dali::Vector3 *)jarg3;
55925   if (!arg3) {
55926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55927     return ;
55928   }
55929   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55930   {
55931     try {
55932       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55933     } catch (std::out_of_range& e) {
55934       {
55935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55936       };
55937     } catch (std::exception& e) {
55938       {
55939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55940       };
55941     } catch (...) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55944       };
55945     }
55946   }
55947 }
55948
55949
55950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55952   Dali::Animation *arg2 = 0 ;
55953   Dali::Vector3 *arg3 = 0 ;
55954   SwigDirector_ViewImpl *darg = 0;
55955
55956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55957   arg2 = (Dali::Animation *)jarg2;
55958   if (!arg2) {
55959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55960     return ;
55961   }
55962   arg3 = (Dali::Vector3 *)jarg3;
55963   if (!arg3) {
55964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55965     return ;
55966   }
55967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55968   {
55969     try {
55970       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55978       };
55979     } catch (...) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55982       };
55983     }
55984   }
55985 }
55986
55987
55988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
55989   unsigned int jresult ;
55990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55991   Dali::TouchEvent *arg2 = 0 ;
55992   SwigDirector_ViewImpl *darg = 0;
55993   bool result;
55994
55995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55996   arg2 = (Dali::TouchEvent *)jarg2;
55997   if (!arg2) {
55998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
55999     return 0;
56000   }
56001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56002   {
56003     try {
56004       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
56005     } catch (std::out_of_range& e) {
56006       {
56007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (std::exception& e) {
56010       {
56011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (...) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56016       };
56017     }
56018   }
56019   jresult = result;
56020   return jresult;
56021 }
56022
56023
56024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56025   unsigned int jresult ;
56026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56027   Dali::TouchEvent *arg2 = 0 ;
56028   SwigDirector_ViewImpl *darg = 0;
56029   bool result;
56030
56031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56032   arg2 = (Dali::TouchEvent *)jarg2;
56033   if (!arg2) {
56034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56035     return 0;
56036   }
56037   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56038   {
56039     try {
56040       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56041     } catch (std::out_of_range& e) {
56042       {
56043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56044       };
56045     } catch (std::exception& e) {
56046       {
56047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56052       };
56053     }
56054   }
56055   jresult = result;
56056   return jresult;
56057 }
56058
56059
56060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56061   unsigned int jresult ;
56062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56063   Dali::HoverEvent *arg2 = 0 ;
56064   SwigDirector_ViewImpl *darg = 0;
56065   bool result;
56066
56067   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56068   arg2 = (Dali::HoverEvent *)jarg2;
56069   if (!arg2) {
56070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56071     return 0;
56072   }
56073   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56074   {
56075     try {
56076       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56077     } catch (std::out_of_range& e) {
56078       {
56079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (std::exception& e) {
56082       {
56083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (...) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56088       };
56089     }
56090   }
56091   jresult = result;
56092   return jresult;
56093 }
56094
56095
56096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56097   unsigned int jresult ;
56098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56099   Dali::HoverEvent *arg2 = 0 ;
56100   SwigDirector_ViewImpl *darg = 0;
56101   bool result;
56102
56103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56104   arg2 = (Dali::HoverEvent *)jarg2;
56105   if (!arg2) {
56106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56107     return 0;
56108   }
56109   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56110   {
56111     try {
56112       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56113     } catch (std::out_of_range& e) {
56114       {
56115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56116       };
56117     } catch (std::exception& e) {
56118       {
56119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56120       };
56121     } catch (...) {
56122       {
56123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56124       };
56125     }
56126   }
56127   jresult = result;
56128   return jresult;
56129 }
56130
56131
56132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56133   unsigned int jresult ;
56134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56135   Dali::KeyEvent *arg2 = 0 ;
56136   SwigDirector_ViewImpl *darg = 0;
56137   bool result;
56138
56139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56140   arg2 = (Dali::KeyEvent *)jarg2;
56141   if (!arg2) {
56142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56143     return 0;
56144   }
56145   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56146   {
56147     try {
56148       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56149     } catch (std::out_of_range& e) {
56150       {
56151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56152       };
56153     } catch (std::exception& e) {
56154       {
56155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56156       };
56157     } catch (...) {
56158       {
56159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56160       };
56161     }
56162   }
56163   jresult = result;
56164   return jresult;
56165 }
56166
56167
56168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56169   unsigned int jresult ;
56170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56171   Dali::KeyEvent *arg2 = 0 ;
56172   SwigDirector_ViewImpl *darg = 0;
56173   bool result;
56174
56175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56176   arg2 = (Dali::KeyEvent *)jarg2;
56177   if (!arg2) {
56178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56179     return 0;
56180   }
56181   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56182   {
56183     try {
56184       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = result;
56200   return jresult;
56201 }
56202
56203
56204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56205   unsigned int jresult ;
56206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56207   Dali::WheelEvent *arg2 = 0 ;
56208   SwigDirector_ViewImpl *darg = 0;
56209   bool result;
56210
56211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56212   arg2 = (Dali::WheelEvent *)jarg2;
56213   if (!arg2) {
56214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56215     return 0;
56216   }
56217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56218   {
56219     try {
56220       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56221     } catch (std::out_of_range& e) {
56222       {
56223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (std::exception& e) {
56226       {
56227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (...) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56232       };
56233     }
56234   }
56235   jresult = result;
56236   return jresult;
56237 }
56238
56239
56240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56241   unsigned int jresult ;
56242   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56243   Dali::WheelEvent *arg2 = 0 ;
56244   SwigDirector_ViewImpl *darg = 0;
56245   bool result;
56246
56247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56248   arg2 = (Dali::WheelEvent *)jarg2;
56249   if (!arg2) {
56250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56251     return 0;
56252   }
56253   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56254   {
56255     try {
56256       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56257     } catch (std::out_of_range& e) {
56258       {
56259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56260       };
56261     } catch (std::exception& e) {
56262       {
56263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (...) {
56266       {
56267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56268       };
56269     }
56270   }
56271   jresult = result;
56272   return jresult;
56273 }
56274
56275
56276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56277   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56278   Dali::Vector2 *arg2 = 0 ;
56279   Dali::RelayoutContainer *arg3 = 0 ;
56280   SwigDirector_ViewImpl *darg = 0;
56281
56282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56283   arg2 = (Dali::Vector2 *)jarg2;
56284   if (!arg2) {
56285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56286     return ;
56287   }
56288   arg3 = (Dali::RelayoutContainer *)jarg3;
56289   if (!arg3) {
56290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56291     return ;
56292   }
56293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56294   {
56295     try {
56296       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56297     } catch (std::out_of_range& e) {
56298       {
56299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56300       };
56301     } catch (std::exception& e) {
56302       {
56303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56304       };
56305     } catch (...) {
56306       {
56307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56308       };
56309     }
56310   }
56311 }
56312
56313
56314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56316   Dali::Vector2 *arg2 = 0 ;
56317   Dali::RelayoutContainer *arg3 = 0 ;
56318   SwigDirector_ViewImpl *darg = 0;
56319
56320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56321   arg2 = (Dali::Vector2 *)jarg2;
56322   if (!arg2) {
56323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56324     return ;
56325   }
56326   arg3 = (Dali::RelayoutContainer *)jarg3;
56327   if (!arg3) {
56328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56329     return ;
56330   }
56331   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56332   {
56333     try {
56334       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56346       };
56347     }
56348   }
56349 }
56350
56351
56352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56353   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56354   Dali::ResizePolicy::Type arg2 ;
56355   Dali::Dimension::Type arg3 ;
56356   SwigDirector_ViewImpl *darg = 0;
56357
56358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56359   arg2 = (Dali::ResizePolicy::Type)jarg2;
56360   arg3 = (Dali::Dimension::Type)jarg3;
56361   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56362   {
56363     try {
56364       (darg)->OnSetResizePolicy(arg2,arg3);
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56372       };
56373     } catch (...) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56376       };
56377     }
56378   }
56379 }
56380
56381
56382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56384   Dali::ResizePolicy::Type arg2 ;
56385   Dali::Dimension::Type arg3 ;
56386   SwigDirector_ViewImpl *darg = 0;
56387
56388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56389   arg2 = (Dali::ResizePolicy::Type)jarg2;
56390   arg3 = (Dali::Dimension::Type)jarg3;
56391   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56392   {
56393     try {
56394       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (...) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56406       };
56407     }
56408   }
56409 }
56410
56411
56412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56413   void * jresult ;
56414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56415   SwigDirector_ViewImpl *darg = 0;
56416   Dali::Vector3 result;
56417
56418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56419   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56420   {
56421     try {
56422       result = (darg)->GetNaturalSize();
56423     } catch (std::out_of_range& e) {
56424       {
56425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (std::exception& e) {
56428       {
56429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56434       };
56435     }
56436   }
56437   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56438   return jresult;
56439 }
56440
56441
56442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56443   void * jresult ;
56444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56445   SwigDirector_ViewImpl *darg = 0;
56446   Dali::Vector3 result;
56447
56448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56450   {
56451     try {
56452       result = (darg)->GetNaturalSizeSwigPublic();
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (...) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56464       };
56465     }
56466   }
56467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56468   return jresult;
56469 }
56470
56471
56472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56473   float jresult ;
56474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56475   Dali::Actor *arg2 = 0 ;
56476   Dali::Dimension::Type arg3 ;
56477   SwigDirector_ViewImpl *darg = 0;
56478   float result;
56479
56480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56481   arg2 = (Dali::Actor *)jarg2;
56482   if (!arg2) {
56483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56484     return 0;
56485   }
56486   arg3 = (Dali::Dimension::Type)jarg3;
56487   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56488   {
56489     try {
56490       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56491     } catch (std::out_of_range& e) {
56492       {
56493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56494       };
56495     } catch (std::exception& e) {
56496       {
56497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (...) {
56500       {
56501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56502       };
56503     }
56504   }
56505   jresult = result;
56506   return jresult;
56507 }
56508
56509
56510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56511   float jresult ;
56512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56513   Dali::Actor *arg2 = 0 ;
56514   Dali::Dimension::Type arg3 ;
56515   SwigDirector_ViewImpl *darg = 0;
56516   float result;
56517
56518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56519   arg2 = (Dali::Actor *)jarg2;
56520   if (!arg2) {
56521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56522     return 0;
56523   }
56524   arg3 = (Dali::Dimension::Type)jarg3;
56525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56526   {
56527     try {
56528       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56529     } catch (std::out_of_range& e) {
56530       {
56531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56532       };
56533     } catch (std::exception& e) {
56534       {
56535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56536       };
56537     } catch (...) {
56538       {
56539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56540       };
56541     }
56542   }
56543   jresult = result;
56544   return jresult;
56545 }
56546
56547
56548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56549   float jresult ;
56550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56551   float arg2 ;
56552   SwigDirector_ViewImpl *darg = 0;
56553   float result;
56554
56555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56556   arg2 = (float)jarg2;
56557   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56558   {
56559     try {
56560       result = (float)(darg)->GetHeightForWidth(arg2);
56561     } catch (std::out_of_range& e) {
56562       {
56563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (std::exception& e) {
56566       {
56567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56568       };
56569     } catch (...) {
56570       {
56571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56572       };
56573     }
56574   }
56575   jresult = result;
56576   return jresult;
56577 }
56578
56579
56580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56581   float jresult ;
56582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56583   float arg2 ;
56584   SwigDirector_ViewImpl *darg = 0;
56585   float result;
56586
56587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56588   arg2 = (float)jarg2;
56589   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56590   {
56591     try {
56592       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56593     } catch (std::out_of_range& e) {
56594       {
56595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56596       };
56597     } catch (std::exception& e) {
56598       {
56599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56600       };
56601     } catch (...) {
56602       {
56603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56604       };
56605     }
56606   }
56607   jresult = result;
56608   return jresult;
56609 }
56610
56611
56612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56613   float jresult ;
56614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56615   float arg2 ;
56616   SwigDirector_ViewImpl *darg = 0;
56617   float result;
56618
56619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56620   arg2 = (float)jarg2;
56621   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56622   {
56623     try {
56624       result = (float)(darg)->GetWidthForHeight(arg2);
56625     } catch (std::out_of_range& e) {
56626       {
56627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (std::exception& e) {
56630       {
56631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56632       };
56633     } catch (...) {
56634       {
56635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56636       };
56637     }
56638   }
56639   jresult = result;
56640   return jresult;
56641 }
56642
56643
56644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56645   float jresult ;
56646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56647   float arg2 ;
56648   SwigDirector_ViewImpl *darg = 0;
56649   float result;
56650
56651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56652   arg2 = (float)jarg2;
56653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56654   {
56655     try {
56656       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56657     } catch (std::out_of_range& e) {
56658       {
56659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56660       };
56661     } catch (std::exception& e) {
56662       {
56663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56664       };
56665     } catch (...) {
56666       {
56667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56668       };
56669     }
56670   }
56671   jresult = result;
56672   return jresult;
56673 }
56674
56675
56676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56677   unsigned int jresult ;
56678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56679   Dali::Dimension::Type arg2 ;
56680   SwigDirector_ViewImpl *darg = 0;
56681   bool result;
56682
56683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56684   arg2 = (Dali::Dimension::Type)jarg2;
56685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56686   {
56687     try {
56688       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56689     } catch (std::out_of_range& e) {
56690       {
56691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56692       };
56693     } catch (std::exception& e) {
56694       {
56695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (...) {
56698       {
56699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56700       };
56701     }
56702   }
56703   jresult = result;
56704   return jresult;
56705 }
56706
56707
56708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56709   unsigned int jresult ;
56710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56711   Dali::Dimension::Type arg2 ;
56712   SwigDirector_ViewImpl *darg = 0;
56713   bool result;
56714
56715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56716   arg2 = (Dali::Dimension::Type)jarg2;
56717   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56718   {
56719     try {
56720       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56721     } catch (std::out_of_range& e) {
56722       {
56723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56724       };
56725     } catch (std::exception& e) {
56726       {
56727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56732       };
56733     }
56734   }
56735   jresult = result;
56736   return jresult;
56737 }
56738
56739
56740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56741   unsigned int jresult ;
56742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56743   SwigDirector_ViewImpl *darg = 0;
56744   bool result;
56745
56746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56747   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56748   {
56749     try {
56750       result = (bool)(darg)->RelayoutDependentOnChildren();
56751     } catch (std::out_of_range& e) {
56752       {
56753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56754       };
56755     } catch (std::exception& e) {
56756       {
56757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56762       };
56763     }
56764   }
56765   jresult = result;
56766   return jresult;
56767 }
56768
56769
56770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56771   unsigned int jresult ;
56772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56773   SwigDirector_ViewImpl *darg = 0;
56774   bool result;
56775
56776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56778   {
56779     try {
56780       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56781     } catch (std::out_of_range& e) {
56782       {
56783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (std::exception& e) {
56786       {
56787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56788       };
56789     } catch (...) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56792       };
56793     }
56794   }
56795   jresult = result;
56796   return jresult;
56797 }
56798
56799
56800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56802   Dali::Dimension::Type arg2 ;
56803   SwigDirector_ViewImpl *darg = 0;
56804
56805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56806   arg2 = (Dali::Dimension::Type)jarg2;
56807   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56808   {
56809     try {
56810       (darg)->OnCalculateRelayoutSize(arg2);
56811     } catch (std::out_of_range& e) {
56812       {
56813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56814       };
56815     } catch (std::exception& e) {
56816       {
56817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56818       };
56819     } catch (...) {
56820       {
56821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56822       };
56823     }
56824   }
56825 }
56826
56827
56828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56830   Dali::Dimension::Type arg2 ;
56831   SwigDirector_ViewImpl *darg = 0;
56832
56833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56834   arg2 = (Dali::Dimension::Type)jarg2;
56835   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56836   {
56837     try {
56838       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56839     } catch (std::out_of_range& e) {
56840       {
56841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56842       };
56843     } catch (std::exception& e) {
56844       {
56845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56846       };
56847     } catch (...) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56850       };
56851     }
56852   }
56853 }
56854
56855
56856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56858   float arg2 ;
56859   Dali::Dimension::Type arg3 ;
56860   SwigDirector_ViewImpl *darg = 0;
56861
56862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56863   arg2 = (float)jarg2;
56864   arg3 = (Dali::Dimension::Type)jarg3;
56865   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56866   {
56867     try {
56868       (darg)->OnLayoutNegotiated(arg2,arg3);
56869     } catch (std::out_of_range& e) {
56870       {
56871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56872       };
56873     } catch (std::exception& e) {
56874       {
56875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56876       };
56877     } catch (...) {
56878       {
56879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56880       };
56881     }
56882   }
56883 }
56884
56885
56886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56888   float arg2 ;
56889   Dali::Dimension::Type arg3 ;
56890   SwigDirector_ViewImpl *darg = 0;
56891
56892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56893   arg2 = (float)jarg2;
56894   arg3 = (Dali::Dimension::Type)jarg3;
56895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56896   {
56897     try {
56898       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
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_OnInitialize(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)->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_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56942
56943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56944   {
56945     try {
56946       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56954       };
56955     } catch (...) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56958       };
56959     }
56960   }
56961 }
56962
56963
56964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56966   Dali::Actor *arg2 = 0 ;
56967
56968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56969   arg2 = (Dali::Actor *)jarg2;
56970   if (!arg2) {
56971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56972     return ;
56973   }
56974   {
56975     try {
56976       (arg1)->OnControlChildAdd(*arg2);
56977     } catch (std::out_of_range& e) {
56978       {
56979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56980       };
56981     } catch (std::exception& e) {
56982       {
56983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56984       };
56985     } catch (...) {
56986       {
56987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56988       };
56989     }
56990   }
56991 }
56992
56993
56994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56996   Dali::Actor *arg2 = 0 ;
56997
56998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56999   arg2 = (Dali::Actor *)jarg2;
57000   if (!arg2) {
57001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57002     return ;
57003   }
57004   {
57005     try {
57006       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
57007     } catch (std::out_of_range& e) {
57008       {
57009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57010       };
57011     } catch (std::exception& e) {
57012       {
57013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57014       };
57015     } catch (...) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57018       };
57019     }
57020   }
57021 }
57022
57023
57024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57026   Dali::Actor *arg2 = 0 ;
57027
57028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57029   arg2 = (Dali::Actor *)jarg2;
57030   if (!arg2) {
57031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57032     return ;
57033   }
57034   {
57035     try {
57036       (arg1)->OnControlChildRemove(*arg2);
57037     } catch (std::out_of_range& e) {
57038       {
57039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57040       };
57041     } catch (std::exception& e) {
57042       {
57043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57044       };
57045     } catch (...) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57048       };
57049     }
57050   }
57051 }
57052
57053
57054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57056   Dali::Actor *arg2 = 0 ;
57057
57058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57059   arg2 = (Dali::Actor *)jarg2;
57060   if (!arg2) {
57061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57062     return ;
57063   }
57064   {
57065     try {
57066       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57067     } catch (std::out_of_range& e) {
57068       {
57069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57070       };
57071     } catch (std::exception& e) {
57072       {
57073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57074       };
57075     } catch (...) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57078       };
57079     }
57080   }
57081 }
57082
57083
57084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57086   Dali::Toolkit::StyleManager arg2 ;
57087   Dali::StyleChange::Type arg3 ;
57088   Dali::Toolkit::StyleManager *argp2 ;
57089
57090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57091   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57092   if (!argp2) {
57093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57094     return ;
57095   }
57096   arg2 = *argp2;
57097   arg3 = (Dali::StyleChange::Type)jarg3;
57098   {
57099     try {
57100       (arg1)->OnStyleChange(arg2,arg3);
57101     } catch (std::out_of_range& e) {
57102       {
57103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57104       };
57105     } catch (std::exception& e) {
57106       {
57107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57108       };
57109     } catch (...) {
57110       {
57111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57112       };
57113     }
57114   }
57115 }
57116
57117
57118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57120   Dali::Toolkit::StyleManager arg2 ;
57121   Dali::StyleChange::Type arg3 ;
57122   Dali::Toolkit::StyleManager *argp2 ;
57123
57124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57125   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57126   if (!argp2) {
57127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57128     return ;
57129   }
57130   arg2 = *argp2;
57131   arg3 = (Dali::StyleChange::Type)jarg3;
57132   {
57133     try {
57134       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57135     } catch (std::out_of_range& e) {
57136       {
57137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57138       };
57139     } catch (std::exception& e) {
57140       {
57141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57142       };
57143     } catch (...) {
57144       {
57145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57146       };
57147     }
57148   }
57149 }
57150
57151
57152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57153   unsigned int jresult ;
57154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57155   bool result;
57156
57157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57158   {
57159     try {
57160       result = (bool)(arg1)->OnAccessibilityActivated();
57161     } catch (std::out_of_range& e) {
57162       {
57163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (std::exception& e) {
57166       {
57167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57168       };
57169     } catch (...) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57172       };
57173     }
57174   }
57175   jresult = result;
57176   return jresult;
57177 }
57178
57179
57180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57181   unsigned int jresult ;
57182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57183   bool result;
57184
57185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57186   {
57187     try {
57188       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57189     } catch (std::out_of_range& e) {
57190       {
57191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57192       };
57193     } catch (std::exception& e) {
57194       {
57195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57196       };
57197     } catch (...) {
57198       {
57199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57200       };
57201     }
57202   }
57203   jresult = result;
57204   return jresult;
57205 }
57206
57207
57208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57209   unsigned int jresult ;
57210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57211   Dali::PanGesture arg2 ;
57212   Dali::PanGesture *argp2 ;
57213   bool result;
57214
57215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57216   argp2 = (Dali::PanGesture *)jarg2;
57217   if (!argp2) {
57218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57219     return 0;
57220   }
57221   arg2 = *argp2;
57222   {
57223     try {
57224       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57225     } catch (std::out_of_range& e) {
57226       {
57227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57228       };
57229     } catch (std::exception& e) {
57230       {
57231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57232       };
57233     } catch (...) {
57234       {
57235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57236       };
57237     }
57238   }
57239   jresult = result;
57240   return jresult;
57241 }
57242
57243
57244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57245   unsigned int jresult ;
57246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57247   Dali::PanGesture arg2 ;
57248   Dali::PanGesture *argp2 ;
57249   bool result;
57250
57251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57252   argp2 = (Dali::PanGesture *)jarg2;
57253   if (!argp2) {
57254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57255     return 0;
57256   }
57257   arg2 = *argp2;
57258   {
57259     try {
57260       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (...) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57272       };
57273     }
57274   }
57275   jresult = result;
57276   return jresult;
57277 }
57278
57279
57280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57281   unsigned int jresult ;
57282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57283   Dali::TouchEvent *arg2 = 0 ;
57284   bool result;
57285
57286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57287   arg2 = (Dali::TouchEvent *)jarg2;
57288   if (!arg2) {
57289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57290     return 0;
57291   }
57292   {
57293     try {
57294       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57295     } catch (std::out_of_range& e) {
57296       {
57297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57298       };
57299     } catch (std::exception& e) {
57300       {
57301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57302       };
57303     } catch (...) {
57304       {
57305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57306       };
57307     }
57308   }
57309   jresult = result;
57310   return jresult;
57311 }
57312
57313
57314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57315   unsigned int jresult ;
57316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57317   Dali::TouchEvent *arg2 = 0 ;
57318   bool result;
57319
57320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57321   arg2 = (Dali::TouchEvent *)jarg2;
57322   if (!arg2) {
57323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57324     return 0;
57325   }
57326   {
57327     try {
57328       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57329     } catch (std::out_of_range& e) {
57330       {
57331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (std::exception& e) {
57334       {
57335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57340       };
57341     }
57342   }
57343   jresult = result;
57344   return jresult;
57345 }
57346
57347
57348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57349   unsigned int jresult ;
57350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57351   bool arg2 ;
57352   bool result;
57353
57354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57355   arg2 = jarg2 ? true : false;
57356   {
57357     try {
57358       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57359     } catch (std::out_of_range& e) {
57360       {
57361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57362       };
57363     } catch (std::exception& e) {
57364       {
57365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57366       };
57367     } catch (...) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57370       };
57371     }
57372   }
57373   jresult = result;
57374   return jresult;
57375 }
57376
57377
57378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57379   unsigned int jresult ;
57380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57381   bool arg2 ;
57382   bool result;
57383
57384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57385   arg2 = jarg2 ? true : false;
57386   {
57387     try {
57388       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (...) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57400       };
57401     }
57402   }
57403   jresult = result;
57404   return jresult;
57405 }
57406
57407
57408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57409   unsigned int jresult ;
57410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57411   bool result;
57412
57413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57414   {
57415     try {
57416       result = (bool)(arg1)->OnAccessibilityZoom();
57417     } catch (std::out_of_range& e) {
57418       {
57419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57420       };
57421     } catch (std::exception& e) {
57422       {
57423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57424       };
57425     } catch (...) {
57426       {
57427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57428       };
57429     }
57430   }
57431   jresult = result;
57432   return jresult;
57433 }
57434
57435
57436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57437   unsigned int jresult ;
57438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57439   bool result;
57440
57441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57442   {
57443     try {
57444       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57445     } catch (std::out_of_range& e) {
57446       {
57447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57448       };
57449     } catch (std::exception& e) {
57450       {
57451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57452       };
57453     } catch (...) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57456       };
57457     }
57458   }
57459   jresult = result;
57460   return jresult;
57461 }
57462
57463
57464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(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)->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_OnKeyInputFocusGainedSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
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_OnKeyInputFocusLost(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)->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_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57538
57539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57540   {
57541     try {
57542       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57543     } catch (std::out_of_range& e) {
57544       {
57545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57546       };
57547     } catch (std::exception& e) {
57548       {
57549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57550       };
57551     } catch (...) {
57552       {
57553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57554       };
57555     }
57556   }
57557 }
57558
57559
57560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57561   void * jresult ;
57562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57563   Dali::Actor arg2 ;
57564   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57565   bool arg4 ;
57566   Dali::Actor *argp2 ;
57567   Dali::Actor result;
57568
57569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57570   argp2 = (Dali::Actor *)jarg2;
57571   if (!argp2) {
57572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57573     return 0;
57574   }
57575   arg2 = *argp2;
57576   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57577   arg4 = jarg4 ? true : false;
57578   {
57579     try {
57580       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57588       };
57589     } catch (...) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57592       };
57593     }
57594   }
57595   jresult = new Dali::Actor((const Dali::Actor &)result);
57596   return jresult;
57597 }
57598
57599
57600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57601   void * jresult ;
57602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57603   Dali::Actor arg2 ;
57604   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57605   bool arg4 ;
57606   Dali::Actor *argp2 ;
57607   Dali::Actor result;
57608
57609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57610   argp2 = (Dali::Actor *)jarg2;
57611   if (!argp2) {
57612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57613     return 0;
57614   }
57615   arg2 = *argp2;
57616   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57617   arg4 = jarg4 ? true : false;
57618   {
57619     try {
57620       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57621     } catch (std::out_of_range& e) {
57622       {
57623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57624       };
57625     } catch (std::exception& e) {
57626       {
57627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57628       };
57629     } catch (...) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57632       };
57633     }
57634   }
57635   jresult = new Dali::Actor((const Dali::Actor &)result);
57636   return jresult;
57637 }
57638
57639
57640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57642   Dali::Actor arg2 ;
57643   Dali::Actor *argp2 ;
57644
57645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57646   argp2 = (Dali::Actor *)jarg2;
57647   if (!argp2) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57649     return ;
57650   }
57651   arg2 = *argp2;
57652   {
57653     try {
57654       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57655     } catch (std::out_of_range& e) {
57656       {
57657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57658       };
57659     } catch (std::exception& e) {
57660       {
57661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57662       };
57663     } catch (...) {
57664       {
57665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57666       };
57667     }
57668   }
57669 }
57670
57671
57672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57674   Dali::Actor arg2 ;
57675   Dali::Actor *argp2 ;
57676
57677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57678   argp2 = (Dali::Actor *)jarg2;
57679   if (!argp2) {
57680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57681     return ;
57682   }
57683   arg2 = *argp2;
57684   {
57685     try {
57686       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57687     } catch (std::out_of_range& e) {
57688       {
57689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57690       };
57691     } catch (std::exception& e) {
57692       {
57693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57694       };
57695     } catch (...) {
57696       {
57697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57698       };
57699     }
57700   }
57701 }
57702
57703
57704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57705   unsigned int jresult ;
57706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57707   bool result;
57708
57709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57710   {
57711     try {
57712       result = (bool)(arg1)->OnKeyboardEnter();
57713     } catch (std::out_of_range& e) {
57714       {
57715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57716       };
57717     } catch (std::exception& e) {
57718       {
57719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57720       };
57721     } catch (...) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57724       };
57725     }
57726   }
57727   jresult = result;
57728   return jresult;
57729 }
57730
57731
57732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57733   unsigned int jresult ;
57734   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57735   bool result;
57736
57737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57738   {
57739     try {
57740       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57741     } catch (std::out_of_range& e) {
57742       {
57743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57744       };
57745     } catch (std::exception& e) {
57746       {
57747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57748       };
57749     } catch (...) {
57750       {
57751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57752       };
57753     }
57754   }
57755   jresult = result;
57756   return jresult;
57757 }
57758
57759
57760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57762   Dali::PinchGesture *arg2 = 0 ;
57763
57764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57765   arg2 = (Dali::PinchGesture *)jarg2;
57766   if (!arg2) {
57767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57768     return ;
57769   }
57770   {
57771     try {
57772       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57773     } catch (std::out_of_range& e) {
57774       {
57775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57776       };
57777     } catch (std::exception& e) {
57778       {
57779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57780       };
57781     } catch (...) {
57782       {
57783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57784       };
57785     }
57786   }
57787 }
57788
57789
57790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57792   Dali::PinchGesture *arg2 = 0 ;
57793
57794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57795   arg2 = (Dali::PinchGesture *)jarg2;
57796   if (!arg2) {
57797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57798     return ;
57799   }
57800   {
57801     try {
57802       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57803     } catch (std::out_of_range& e) {
57804       {
57805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57806       };
57807     } catch (std::exception& e) {
57808       {
57809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57810       };
57811     } catch (...) {
57812       {
57813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57814       };
57815     }
57816   }
57817 }
57818
57819
57820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57822   Dali::PanGesture *arg2 = 0 ;
57823
57824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57825   arg2 = (Dali::PanGesture *)jarg2;
57826   if (!arg2) {
57827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57828     return ;
57829   }
57830   {
57831     try {
57832       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
57833     } catch (std::out_of_range& e) {
57834       {
57835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57836       };
57837     } catch (std::exception& e) {
57838       {
57839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57840       };
57841     } catch (...) {
57842       {
57843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57844       };
57845     }
57846   }
57847 }
57848
57849
57850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57852   Dali::PanGesture *arg2 = 0 ;
57853
57854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57855   arg2 = (Dali::PanGesture *)jarg2;
57856   if (!arg2) {
57857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57858     return ;
57859   }
57860   {
57861     try {
57862       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57863     } catch (std::out_of_range& e) {
57864       {
57865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57866       };
57867     } catch (std::exception& e) {
57868       {
57869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57870       };
57871     } catch (...) {
57872       {
57873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57874       };
57875     }
57876   }
57877 }
57878
57879
57880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57882   Dali::TapGesture *arg2 = 0 ;
57883
57884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57885   arg2 = (Dali::TapGesture *)jarg2;
57886   if (!arg2) {
57887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57888     return ;
57889   }
57890   {
57891     try {
57892       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
57893     } catch (std::out_of_range& e) {
57894       {
57895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57896       };
57897     } catch (std::exception& e) {
57898       {
57899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57900       };
57901     } catch (...) {
57902       {
57903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57904       };
57905     }
57906   }
57907 }
57908
57909
57910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57912   Dali::TapGesture *arg2 = 0 ;
57913
57914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57915   arg2 = (Dali::TapGesture *)jarg2;
57916   if (!arg2) {
57917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57918     return ;
57919   }
57920   {
57921     try {
57922       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57923     } catch (std::out_of_range& e) {
57924       {
57925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57926       };
57927     } catch (std::exception& e) {
57928       {
57929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57930       };
57931     } catch (...) {
57932       {
57933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57934       };
57935     }
57936   }
57937 }
57938
57939
57940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57942   Dali::LongPressGesture *arg2 = 0 ;
57943
57944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57945   arg2 = (Dali::LongPressGesture *)jarg2;
57946   if (!arg2) {
57947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57948     return ;
57949   }
57950   {
57951     try {
57952       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57953     } catch (std::out_of_range& e) {
57954       {
57955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57956       };
57957     } catch (std::exception& e) {
57958       {
57959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57960       };
57961     } catch (...) {
57962       {
57963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57964       };
57965     }
57966   }
57967 }
57968
57969
57970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57972   Dali::LongPressGesture *arg2 = 0 ;
57973
57974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57975   arg2 = (Dali::LongPressGesture *)jarg2;
57976   if (!arg2) {
57977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57978     return ;
57979   }
57980   {
57981     try {
57982       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
57983     } catch (std::out_of_range& e) {
57984       {
57985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57986       };
57987     } catch (std::exception& e) {
57988       {
57989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57990       };
57991     } catch (...) {
57992       {
57993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57994       };
57995     }
57996   }
57997 }
57998
57999
58000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58002   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58003   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58004
58005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58006   arg2 = (Dali::SlotObserver *)jarg2;
58007   arg3 = (Dali::CallbackBase *)jarg3;
58008   {
58009     try {
58010       (arg1)->SignalConnected(arg2,arg3);
58011     } catch (std::out_of_range& e) {
58012       {
58013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58014       };
58015     } catch (std::exception& e) {
58016       {
58017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58018       };
58019     } catch (...) {
58020       {
58021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58022       };
58023     }
58024   }
58025 }
58026
58027
58028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58030   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58031   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58032
58033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58034   arg2 = (Dali::SlotObserver *)jarg2;
58035   arg3 = (Dali::CallbackBase *)jarg3;
58036   {
58037     try {
58038       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58039     } catch (std::out_of_range& e) {
58040       {
58041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58042       };
58043     } catch (std::exception& e) {
58044       {
58045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58046       };
58047     } catch (...) {
58048       {
58049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58050       };
58051     }
58052   }
58053 }
58054
58055
58056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58058   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58059   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58060
58061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58062   arg2 = (Dali::SlotObserver *)jarg2;
58063   arg3 = (Dali::CallbackBase *)jarg3;
58064   {
58065     try {
58066       (arg1)->SignalDisconnected(arg2,arg3);
58067     } catch (std::out_of_range& e) {
58068       {
58069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58070       };
58071     } catch (std::exception& e) {
58072       {
58073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58074       };
58075     } catch (...) {
58076       {
58077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58078       };
58079     }
58080   }
58081 }
58082
58083
58084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58086   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58087   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58088
58089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58090   arg2 = (Dali::SlotObserver *)jarg2;
58091   arg3 = (Dali::CallbackBase *)jarg3;
58092   {
58093     try {
58094       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58095     } catch (std::out_of_range& e) {
58096       {
58097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58098       };
58099     } catch (std::exception& e) {
58100       {
58101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58102       };
58103     } catch (...) {
58104       {
58105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58106       };
58107     }
58108   }
58109 }
58110
58111
58112 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) {
58113   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58114   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58115   if (director) {
58116     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);
58117   }
58118 }
58119
58120
58121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58122   void * jresult ;
58123   Dali::Toolkit::Control *arg1 = 0 ;
58124   Dali::Toolkit::Internal::Control *result = 0 ;
58125
58126   arg1 = (Dali::Toolkit::Control *)jarg1;
58127   if (!arg1) {
58128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58129     return 0;
58130   }
58131   {
58132     try {
58133       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58134     } catch (std::out_of_range& e) {
58135       {
58136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58137       };
58138     } catch (std::exception& e) {
58139       {
58140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (...) {
58143       {
58144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58145       };
58146     }
58147   }
58148   jresult = (void *)result;
58149   return jresult;
58150 }
58151
58152
58153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58154   int jresult ;
58155   int result;
58156
58157   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58158   jresult = (int)result;
58159   return jresult;
58160 }
58161
58162
58163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58164   int jresult ;
58165   int result;
58166
58167   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58168   jresult = (int)result;
58169   return jresult;
58170 }
58171
58172
58173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58174   int jresult ;
58175   int result;
58176
58177   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58178   jresult = (int)result;
58179   return jresult;
58180 }
58181
58182
58183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58184   int jresult ;
58185   int result;
58186
58187   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58188   jresult = (int)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58194   int jresult ;
58195   int result;
58196
58197   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58198   jresult = (int)result;
58199   return jresult;
58200 }
58201
58202
58203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58204   void * jresult ;
58205   Dali::Toolkit::Control::Property *result = 0 ;
58206
58207   {
58208     try {
58209       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58210     } catch (std::out_of_range& e) {
58211       {
58212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58213       };
58214     } catch (std::exception& e) {
58215       {
58216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58217       };
58218     } catch (...) {
58219       {
58220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58221       };
58222     }
58223   }
58224   jresult = (void *)result;
58225   return jresult;
58226 }
58227
58228
58229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58230   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58231
58232   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58233   {
58234     try {
58235       delete arg1;
58236     } catch (std::out_of_range& e) {
58237       {
58238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58239       };
58240     } catch (std::exception& e) {
58241       {
58242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58243       };
58244     } catch (...) {
58245       {
58246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58247       };
58248     }
58249   }
58250 }
58251
58252
58253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58254   void * jresult ;
58255   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58256
58257   {
58258     try {
58259       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58260     } catch (std::out_of_range& e) {
58261       {
58262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58263       };
58264     } catch (std::exception& e) {
58265       {
58266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58267       };
58268     } catch (...) {
58269       {
58270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58271       };
58272     }
58273   }
58274   jresult = (void *)result;
58275   return jresult;
58276 }
58277
58278
58279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58280   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58281
58282   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58283   {
58284     try {
58285       delete arg1;
58286     } catch (std::out_of_range& e) {
58287       {
58288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58289       };
58290     } catch (std::exception& e) {
58291       {
58292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58293       };
58294     } catch (...) {
58295       {
58296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58297       };
58298     }
58299   }
58300 }
58301
58302
58303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58304   void * jresult ;
58305   Dali::Toolkit::Control result;
58306
58307   {
58308     try {
58309       result = Dali::Toolkit::Control::New();
58310     } catch (std::out_of_range& e) {
58311       {
58312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58313       };
58314     } catch (std::exception& e) {
58315       {
58316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58317       };
58318     } catch (...) {
58319       {
58320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58321       };
58322     }
58323   }
58324   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58325   return jresult;
58326 }
58327
58328
58329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58330   void * jresult ;
58331   Dali::Toolkit::Control *result = 0 ;
58332
58333   {
58334     try {
58335       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58336     } catch (std::out_of_range& e) {
58337       {
58338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58339       };
58340     } catch (std::exception& e) {
58341       {
58342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58343       };
58344     } catch (...) {
58345       {
58346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58347       };
58348     }
58349   }
58350   jresult = (void *)result;
58351   return jresult;
58352 }
58353
58354
58355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58356   void * jresult ;
58357   Dali::Toolkit::Control *arg1 = 0 ;
58358   Dali::Toolkit::Control *result = 0 ;
58359
58360   arg1 = (Dali::Toolkit::Control *)jarg1;
58361   if (!arg1) {
58362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58363     return 0;
58364   }
58365   {
58366     try {
58367       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58368     } catch (std::out_of_range& e) {
58369       {
58370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58371       };
58372     } catch (std::exception& e) {
58373       {
58374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58375       };
58376     } catch (...) {
58377       {
58378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58379       };
58380     }
58381   }
58382   jresult = (void *)result;
58383   return jresult;
58384 }
58385
58386
58387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58388   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58389
58390   arg1 = (Dali::Toolkit::Control *)jarg1;
58391   {
58392     try {
58393       delete arg1;
58394     } catch (std::out_of_range& e) {
58395       {
58396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58397       };
58398     } catch (std::exception& e) {
58399       {
58400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58401       };
58402     } catch (...) {
58403       {
58404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58405       };
58406     }
58407   }
58408 }
58409
58410
58411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58412   void * jresult ;
58413   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58414   Dali::Toolkit::Control *arg2 = 0 ;
58415   Dali::Toolkit::Control *result = 0 ;
58416
58417   arg1 = (Dali::Toolkit::Control *)jarg1;
58418   arg2 = (Dali::Toolkit::Control *)jarg2;
58419   if (!arg2) {
58420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58421     return 0;
58422   }
58423   {
58424     try {
58425       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58426     } catch (std::out_of_range& e) {
58427       {
58428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58429       };
58430     } catch (std::exception& e) {
58431       {
58432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (...) {
58435       {
58436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58437       };
58438     }
58439   }
58440   jresult = (void *)result;
58441   return jresult;
58442 }
58443
58444
58445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58446   void * jresult ;
58447   Dali::BaseHandle arg1 ;
58448   Dali::BaseHandle *argp1 ;
58449   Dali::Toolkit::Control result;
58450
58451   argp1 = (Dali::BaseHandle *)jarg1;
58452   if (!argp1) {
58453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58454     return 0;
58455   }
58456   arg1 = *argp1;
58457   {
58458     try {
58459       result = Dali::Toolkit::Control::DownCast(arg1);
58460     } catch (std::out_of_range& e) {
58461       {
58462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58463       };
58464     } catch (std::exception& e) {
58465       {
58466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58467       };
58468     } catch (...) {
58469       {
58470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58471       };
58472     }
58473   }
58474   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58475   return jresult;
58476 }
58477
58478
58479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58480   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58481
58482   arg1 = (Dali::Toolkit::Control *)jarg1;
58483   {
58484     try {
58485       (arg1)->SetKeyInputFocus();
58486     } catch (std::out_of_range& e) {
58487       {
58488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58489       };
58490     } catch (std::exception& e) {
58491       {
58492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58493       };
58494     } catch (...) {
58495       {
58496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58497       };
58498     }
58499   }
58500 }
58501
58502
58503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58504   unsigned int jresult ;
58505   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58506   bool result;
58507
58508   arg1 = (Dali::Toolkit::Control *)jarg1;
58509   {
58510     try {
58511       result = (bool)(arg1)->HasKeyInputFocus();
58512     } catch (std::out_of_range& e) {
58513       {
58514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58515       };
58516     } catch (std::exception& e) {
58517       {
58518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (...) {
58521       {
58522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58523       };
58524     }
58525   }
58526   jresult = result;
58527   return jresult;
58528 }
58529
58530
58531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58532   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58533
58534   arg1 = (Dali::Toolkit::Control *)jarg1;
58535   {
58536     try {
58537       (arg1)->ClearKeyInputFocus();
58538     } catch (std::out_of_range& e) {
58539       {
58540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58541       };
58542     } catch (std::exception& e) {
58543       {
58544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58545       };
58546     } catch (...) {
58547       {
58548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58549       };
58550     }
58551   }
58552 }
58553
58554
58555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58556   void * jresult ;
58557   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58558   Dali::PinchGestureDetector result;
58559
58560   arg1 = (Dali::Toolkit::Control *)jarg1;
58561   {
58562     try {
58563       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58564     } catch (std::out_of_range& e) {
58565       {
58566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58567       };
58568     } catch (std::exception& e) {
58569       {
58570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58571       };
58572     } catch (...) {
58573       {
58574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58575       };
58576     }
58577   }
58578   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58579   return jresult;
58580 }
58581
58582
58583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58584   void * jresult ;
58585   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58586   Dali::PanGestureDetector result;
58587
58588   arg1 = (Dali::Toolkit::Control *)jarg1;
58589   {
58590     try {
58591       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58599       };
58600     } catch (...) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58603       };
58604     }
58605   }
58606   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58607   return jresult;
58608 }
58609
58610
58611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58612   void * jresult ;
58613   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58614   Dali::TapGestureDetector result;
58615
58616   arg1 = (Dali::Toolkit::Control *)jarg1;
58617   {
58618     try {
58619       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58620     } catch (std::out_of_range& e) {
58621       {
58622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58623       };
58624     } catch (std::exception& e) {
58625       {
58626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (...) {
58629       {
58630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58631       };
58632     }
58633   }
58634   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58635   return jresult;
58636 }
58637
58638
58639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58640   void * jresult ;
58641   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58642   Dali::LongPressGestureDetector result;
58643
58644   arg1 = (Dali::Toolkit::Control *)jarg1;
58645   {
58646     try {
58647       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58648     } catch (std::out_of_range& e) {
58649       {
58650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58651       };
58652     } catch (std::exception& e) {
58653       {
58654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58655       };
58656     } catch (...) {
58657       {
58658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58659       };
58660     }
58661   }
58662   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58663   return jresult;
58664 }
58665
58666
58667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58668   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58669   std::string *arg2 = 0 ;
58670
58671   arg1 = (Dali::Toolkit::Control *)jarg1;
58672   if (!jarg2) {
58673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58674     return ;
58675   }
58676   std::string arg2_str(jarg2);
58677   arg2 = &arg2_str;
58678   {
58679     try {
58680       (arg1)->SetStyleName((std::string const &)*arg2);
58681     } catch (std::out_of_range& e) {
58682       {
58683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58684       };
58685     } catch (std::exception& e) {
58686       {
58687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58688       };
58689     } catch (...) {
58690       {
58691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58692       };
58693     }
58694   }
58695
58696   //argout typemap for const std::string&
58697
58698 }
58699
58700
58701 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58702   char * jresult ;
58703   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58704   std::string *result = 0 ;
58705
58706   arg1 = (Dali::Toolkit::Control *)jarg1;
58707   {
58708     try {
58709       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58710     } catch (std::out_of_range& e) {
58711       {
58712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58713       };
58714     } catch (std::exception& e) {
58715       {
58716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58717       };
58718     } catch (...) {
58719       {
58720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58721       };
58722     }
58723   }
58724   jresult = SWIG_csharp_string_callback(result->c_str());
58725   return jresult;
58726 }
58727
58728
58729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58731   Dali::Vector4 *arg2 = 0 ;
58732
58733   arg1 = (Dali::Toolkit::Control *)jarg1;
58734   arg2 = (Dali::Vector4 *)jarg2;
58735   if (!arg2) {
58736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58737     return ;
58738   }
58739   {
58740     try {
58741       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58742     } catch (std::out_of_range& e) {
58743       {
58744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58745       };
58746     } catch (std::exception& e) {
58747       {
58748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58749       };
58750     } catch (...) {
58751       {
58752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58753       };
58754     }
58755   }
58756 }
58757
58758
58759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58760   void * jresult ;
58761   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58762   Dali::Vector4 result;
58763
58764   arg1 = (Dali::Toolkit::Control *)jarg1;
58765   {
58766     try {
58767       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58768     } catch (std::out_of_range& e) {
58769       {
58770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58771       };
58772     } catch (std::exception& e) {
58773       {
58774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58775       };
58776     } catch (...) {
58777       {
58778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58779       };
58780     }
58781   }
58782   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58783   return jresult;
58784 }
58785
58786
58787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58789   Dali::Image arg2 ;
58790   Dali::Image *argp2 ;
58791
58792   arg1 = (Dali::Toolkit::Control *)jarg1;
58793   argp2 = (Dali::Image *)jarg2;
58794   if (!argp2) {
58795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58796     return ;
58797   }
58798   arg2 = *argp2;
58799   {
58800     try {
58801       (arg1)->SetBackgroundImage(arg2);
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_ClearBackground(void * jarg1) {
58820   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58821
58822   arg1 = (Dali::Toolkit::Control *)jarg1;
58823   {
58824     try {
58825       (arg1)->ClearBackground();
58826     } catch (std::out_of_range& e) {
58827       {
58828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58829       };
58830     } catch (std::exception& e) {
58831       {
58832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58833       };
58834     } catch (...) {
58835       {
58836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58837       };
58838     }
58839   }
58840 }
58841
58842
58843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58844   void * jresult ;
58845   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58846   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58847
58848   arg1 = (Dali::Toolkit::Control *)jarg1;
58849   {
58850     try {
58851       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58852     } catch (std::out_of_range& e) {
58853       {
58854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58855       };
58856     } catch (std::exception& e) {
58857       {
58858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (...) {
58861       {
58862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58863       };
58864     }
58865   }
58866   jresult = (void *)result;
58867   return jresult;
58868 }
58869
58870
58871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58872   void * jresult ;
58873   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58874   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58875
58876   arg1 = (Dali::Toolkit::Control *)jarg1;
58877   {
58878     try {
58879       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58880     } catch (std::out_of_range& e) {
58881       {
58882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58883       };
58884     } catch (std::exception& e) {
58885       {
58886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (...) {
58889       {
58890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58891       };
58892     }
58893   }
58894   jresult = (void *)result;
58895   return jresult;
58896 }
58897
58898
58899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58900   void * jresult ;
58901   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58902   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58903
58904   arg1 = (Dali::Toolkit::Control *)jarg1;
58905   {
58906     try {
58907       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58908     } catch (std::out_of_range& e) {
58909       {
58910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58911       };
58912     } catch (std::exception& e) {
58913       {
58914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58915       };
58916     } catch (...) {
58917       {
58918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58919       };
58920     }
58921   }
58922   jresult = (void *)result;
58923   return jresult;
58924 }
58925
58926
58927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58928   void * jresult ;
58929   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58930   Dali::Toolkit::Control *result = 0 ;
58931
58932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58933   if (!arg1) {
58934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58935     return 0;
58936   }
58937   {
58938     try {
58939       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58940     } catch (std::out_of_range& e) {
58941       {
58942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58943       };
58944     } catch (std::exception& e) {
58945       {
58946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58947       };
58948     } catch (...) {
58949       {
58950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58951       };
58952     }
58953   }
58954   jresult = (void *)result;
58955   return jresult;
58956 }
58957
58958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58959 {
58960   void * jresult;
58961   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58962   arg1 = (Dali::Toolkit::Control *)jarg1;
58963
58964   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58965
58966   Dali::Toolkit::TransitionData *arg2 = 0 ;
58967   Dali::Animation result;
58968
58969   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58970   if (!arg2) {
58971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58972     return 0;
58973   }
58974   {
58975     try {
58976       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (...) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58988       };
58989     }
58990   }
58991   jresult = new Dali::Animation((const Dali::Animation &)result);
58992   return jresult;
58993 }
58994
58995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
58996   void * jresult ;
58997   Dali::Toolkit::Control *arg1 = 0 ;
58998   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
58999
59000   arg1 = (Dali::Toolkit::Control *)jarg1;
59001   if (!arg1) {
59002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59003     return 0;
59004   }
59005   {
59006     try {
59007       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
59008     } catch (std::out_of_range& e) {
59009       {
59010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59011       };
59012     } catch (std::exception& e) {
59013       {
59014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59015       };
59016     } catch (...) {
59017       {
59018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59019       };
59020     }
59021   }
59022   jresult = (void *)result;
59023   return jresult;
59024 }
59025
59026
59027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59028   unsigned int jresult ;
59029   Dali::Toolkit::Control *arg1 = 0 ;
59030   bool result;
59031
59032   arg1 = (Dali::Toolkit::Control *)jarg1;
59033   if (!arg1) {
59034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59035     return 0;
59036   }
59037   {
59038     try {
59039       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59047       };
59048     } catch (...) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59051       };
59052     }
59053   }
59054   jresult = result;
59055   return jresult;
59056 }
59057
59058
59059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59060   void * jresult ;
59061   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59062
59063   {
59064     try {
59065       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59066     } catch (std::out_of_range& e) {
59067       {
59068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59069       };
59070     } catch (std::exception& e) {
59071       {
59072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59073       };
59074     } catch (...) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59077       };
59078     }
59079   }
59080   jresult = (void *)result;
59081   return jresult;
59082 }
59083
59084
59085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59086   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59087
59088   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59089   {
59090     try {
59091       delete arg1;
59092     } catch (std::out_of_range& e) {
59093       {
59094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59095       };
59096     } catch (std::exception& e) {
59097       {
59098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59099       };
59100     } catch (...) {
59101       {
59102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59103       };
59104     }
59105   }
59106 }
59107
59108
59109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59110   void * jresult ;
59111   Dali::Toolkit::KeyInputFocusManager result;
59112
59113   {
59114     try {
59115       result = Dali::Toolkit::KeyInputFocusManager::Get();
59116     } catch (std::out_of_range& e) {
59117       {
59118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59119       };
59120     } catch (std::exception& e) {
59121       {
59122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59123       };
59124     } catch (...) {
59125       {
59126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59127       };
59128     }
59129   }
59130   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59131   return jresult;
59132 }
59133
59134
59135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59136   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59137   Dali::Toolkit::Control arg2 ;
59138   Dali::Toolkit::Control *argp2 ;
59139
59140   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59141   argp2 = (Dali::Toolkit::Control *)jarg2;
59142   if (!argp2) {
59143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59144     return ;
59145   }
59146   arg2 = *argp2;
59147   {
59148     try {
59149       (arg1)->SetFocus(arg2);
59150     } catch (std::out_of_range& e) {
59151       {
59152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59153       };
59154     } catch (std::exception& e) {
59155       {
59156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59157       };
59158     } catch (...) {
59159       {
59160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59161       };
59162     }
59163   }
59164 }
59165
59166
59167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59168   void * jresult ;
59169   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59170   Dali::Toolkit::Control result;
59171
59172   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59173   {
59174     try {
59175       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59176     } catch (std::out_of_range& e) {
59177       {
59178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59179       };
59180     } catch (std::exception& e) {
59181       {
59182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59183       };
59184     } catch (...) {
59185       {
59186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59187       };
59188     }
59189   }
59190   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59191   return jresult;
59192 }
59193
59194
59195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59196   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59197   Dali::Toolkit::Control arg2 ;
59198   Dali::Toolkit::Control *argp2 ;
59199
59200   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59201   argp2 = (Dali::Toolkit::Control *)jarg2;
59202   if (!argp2) {
59203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59204     return ;
59205   }
59206   arg2 = *argp2;
59207   {
59208     try {
59209       (arg1)->RemoveFocus(arg2);
59210     } catch (std::out_of_range& e) {
59211       {
59212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59213       };
59214     } catch (std::exception& e) {
59215       {
59216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59217       };
59218     } catch (...) {
59219       {
59220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59221       };
59222     }
59223   }
59224 }
59225
59226
59227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59228   void * jresult ;
59229   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59230   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59231
59232   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59233   {
59234     try {
59235       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59236     } catch (std::out_of_range& e) {
59237       {
59238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59239       };
59240     } catch (std::exception& e) {
59241       {
59242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59243       };
59244     } catch (...) {
59245       {
59246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59247       };
59248     }
59249   }
59250   jresult = (void *)result;
59251   return jresult;
59252 }
59253
59254
59255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59256   void * jresult ;
59257   Dali::Toolkit::Alignment::Padding *result = 0 ;
59258
59259   {
59260     try {
59261       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59262     } catch (std::out_of_range& e) {
59263       {
59264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59265       };
59266     } catch (std::exception& e) {
59267       {
59268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (...) {
59271       {
59272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59273       };
59274     }
59275   }
59276   jresult = (void *)result;
59277   return jresult;
59278 }
59279
59280
59281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59282   void * jresult ;
59283   float arg1 ;
59284   float arg2 ;
59285   float arg3 ;
59286   float arg4 ;
59287   Dali::Toolkit::Alignment::Padding *result = 0 ;
59288
59289   arg1 = (float)jarg1;
59290   arg2 = (float)jarg2;
59291   arg3 = (float)jarg3;
59292   arg4 = (float)jarg4;
59293   {
59294     try {
59295       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59296     } catch (std::out_of_range& e) {
59297       {
59298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59299       };
59300     } catch (std::exception& e) {
59301       {
59302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59303       };
59304     } catch (...) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59307       };
59308     }
59309   }
59310   jresult = (void *)result;
59311   return jresult;
59312 }
59313
59314
59315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59316   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59317   float arg2 ;
59318
59319   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59320   arg2 = (float)jarg2;
59321   if (arg1) (arg1)->left = arg2;
59322 }
59323
59324
59325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59326   float jresult ;
59327   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59328   float result;
59329
59330   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59331   result = (float) ((arg1)->left);
59332   jresult = result;
59333   return jresult;
59334 }
59335
59336
59337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59338   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59339   float arg2 ;
59340
59341   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59342   arg2 = (float)jarg2;
59343   if (arg1) (arg1)->right = arg2;
59344 }
59345
59346
59347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59348   float jresult ;
59349   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59350   float result;
59351
59352   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59353   result = (float) ((arg1)->right);
59354   jresult = result;
59355   return jresult;
59356 }
59357
59358
59359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59360   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59361   float arg2 ;
59362
59363   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59364   arg2 = (float)jarg2;
59365   if (arg1) (arg1)->top = arg2;
59366 }
59367
59368
59369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59370   float jresult ;
59371   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59372   float result;
59373
59374   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59375   result = (float) ((arg1)->top);
59376   jresult = result;
59377   return jresult;
59378 }
59379
59380
59381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59382   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59383   float arg2 ;
59384
59385   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59386   arg2 = (float)jarg2;
59387   if (arg1) (arg1)->bottom = arg2;
59388 }
59389
59390
59391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59392   float jresult ;
59393   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59394   float result;
59395
59396   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59397   result = (float) ((arg1)->bottom);
59398   jresult = result;
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59404   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59405
59406   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59407   {
59408     try {
59409       delete arg1;
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59417       };
59418     } catch (...) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59421       };
59422     }
59423   }
59424 }
59425
59426
59427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59428   void * jresult ;
59429   Dali::Toolkit::Alignment *result = 0 ;
59430
59431   {
59432     try {
59433       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59434     } catch (std::out_of_range& e) {
59435       {
59436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59437       };
59438     } catch (std::exception& e) {
59439       {
59440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (...) {
59443       {
59444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59445       };
59446     }
59447   }
59448   jresult = (void *)result;
59449   return jresult;
59450 }
59451
59452
59453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59454   void * jresult ;
59455   Dali::Toolkit::Alignment::Type arg1 ;
59456   Dali::Toolkit::Alignment::Type arg2 ;
59457   Dali::Toolkit::Alignment result;
59458
59459   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59460   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59461   {
59462     try {
59463       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59464     } catch (std::out_of_range& e) {
59465       {
59466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59467       };
59468     } catch (std::exception& e) {
59469       {
59470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59471       };
59472     } catch (...) {
59473       {
59474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59475       };
59476     }
59477   }
59478   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59479   return jresult;
59480 }
59481
59482
59483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59484   void * jresult ;
59485   Dali::Toolkit::Alignment::Type arg1 ;
59486   Dali::Toolkit::Alignment result;
59487
59488   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59489   {
59490     try {
59491       result = Dali::Toolkit::Alignment::New(arg1);
59492     } catch (std::out_of_range& e) {
59493       {
59494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59495       };
59496     } catch (std::exception& e) {
59497       {
59498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59499       };
59500     } catch (...) {
59501       {
59502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59503       };
59504     }
59505   }
59506   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59507   return jresult;
59508 }
59509
59510
59511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59512   void * jresult ;
59513   Dali::Toolkit::Alignment result;
59514
59515   {
59516     try {
59517       result = Dali::Toolkit::Alignment::New();
59518     } catch (std::out_of_range& e) {
59519       {
59520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59521       };
59522     } catch (std::exception& e) {
59523       {
59524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59525       };
59526     } catch (...) {
59527       {
59528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59529       };
59530     }
59531   }
59532   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59533   return jresult;
59534 }
59535
59536
59537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59538   void * jresult ;
59539   Dali::Toolkit::Alignment *arg1 = 0 ;
59540   Dali::Toolkit::Alignment *result = 0 ;
59541
59542   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59543   if (!arg1) {
59544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59545     return 0;
59546   }
59547   {
59548     try {
59549       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59550     } catch (std::out_of_range& e) {
59551       {
59552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (std::exception& e) {
59555       {
59556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564   jresult = (void *)result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59570   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59571
59572   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59573   {
59574     try {
59575       delete arg1;
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59587       };
59588     }
59589   }
59590 }
59591
59592
59593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59594   void * jresult ;
59595   Dali::BaseHandle arg1 ;
59596   Dali::BaseHandle *argp1 ;
59597   Dali::Toolkit::Alignment result;
59598
59599   argp1 = (Dali::BaseHandle *)jarg1;
59600   if (!argp1) {
59601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59602     return 0;
59603   }
59604   arg1 = *argp1;
59605   {
59606     try {
59607       result = Dali::Toolkit::Alignment::DownCast(arg1);
59608     } catch (std::out_of_range& e) {
59609       {
59610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (std::exception& e) {
59613       {
59614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (...) {
59617       {
59618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59619       };
59620     }
59621   }
59622   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59628   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59629   Dali::Toolkit::Alignment::Type arg2 ;
59630
59631   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59632   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59633   {
59634     try {
59635       (arg1)->SetAlignmentType(arg2);
59636     } catch (std::out_of_range& e) {
59637       {
59638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59639       };
59640     } catch (std::exception& e) {
59641       {
59642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59643       };
59644     } catch (...) {
59645       {
59646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59647       };
59648     }
59649   }
59650 }
59651
59652
59653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59654   int jresult ;
59655   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59656   Dali::Toolkit::Alignment::Type result;
59657
59658   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59659   {
59660     try {
59661       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676   jresult = (int)result;
59677   return jresult;
59678 }
59679
59680
59681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59682   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59683   Dali::Toolkit::Alignment::Scaling arg2 ;
59684
59685   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59686   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59687   {
59688     try {
59689       (arg1)->SetScaling(arg2);
59690     } catch (std::out_of_range& e) {
59691       {
59692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59693       };
59694     } catch (std::exception& e) {
59695       {
59696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59697       };
59698     } catch (...) {
59699       {
59700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59701       };
59702     }
59703   }
59704 }
59705
59706
59707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59708   int jresult ;
59709   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59710   Dali::Toolkit::Alignment::Scaling result;
59711
59712   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59713   {
59714     try {
59715       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59716     } catch (std::out_of_range& e) {
59717       {
59718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (std::exception& e) {
59721       {
59722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730   jresult = (int)result;
59731   return jresult;
59732 }
59733
59734
59735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59736   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59737   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59738
59739   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59740   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59741   if (!arg2) {
59742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59743     return ;
59744   }
59745   {
59746     try {
59747       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59748     } catch (std::out_of_range& e) {
59749       {
59750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59751       };
59752     } catch (std::exception& e) {
59753       {
59754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59755       };
59756     } catch (...) {
59757       {
59758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59759       };
59760     }
59761   }
59762 }
59763
59764
59765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59766   void * jresult ;
59767   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59768   Dali::Toolkit::Alignment::Padding *result = 0 ;
59769
59770   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59771   {
59772     try {
59773       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59774     } catch (std::out_of_range& e) {
59775       {
59776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (std::exception& e) {
59779       {
59780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (...) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59785       };
59786     }
59787   }
59788   jresult = (void *)result;
59789   return jresult;
59790 }
59791
59792
59793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59794   void * jresult ;
59795   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59796   Dali::Toolkit::Alignment *arg2 = 0 ;
59797   Dali::Toolkit::Alignment *result = 0 ;
59798
59799   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59800   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59801   if (!arg2) {
59802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59803     return 0;
59804   }
59805   {
59806     try {
59807       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59808     } catch (std::out_of_range& e) {
59809       {
59810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59811       };
59812     } catch (std::exception& e) {
59813       {
59814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59815       };
59816     } catch (...) {
59817       {
59818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59819       };
59820     }
59821   }
59822   jresult = (void *)result;
59823   return jresult;
59824 }
59825
59826
59827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59828   int jresult ;
59829   int result;
59830
59831   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836
59837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59838   int jresult ;
59839   int result;
59840
59841   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59842   jresult = (int)result;
59843   return jresult;
59844 }
59845
59846
59847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59848   int jresult ;
59849   int result;
59850
59851   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59852   jresult = (int)result;
59853   return jresult;
59854 }
59855
59856
59857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59858   int jresult ;
59859   int result;
59860
59861   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866
59867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59868   int jresult ;
59869   int result;
59870
59871   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59872   jresult = (int)result;
59873   return jresult;
59874 }
59875
59876
59877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59878   int jresult ;
59879   int result;
59880
59881   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59882   jresult = (int)result;
59883   return jresult;
59884 }
59885
59886
59887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59888   int jresult ;
59889   int result;
59890
59891   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59898   int jresult ;
59899   int result;
59900
59901   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59902   jresult = (int)result;
59903   return jresult;
59904 }
59905
59906
59907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59908   int jresult ;
59909   int result;
59910
59911   result = (int)Dali::Toolkit::Button::Property::LABEL;
59912   jresult = (int)result;
59913   return jresult;
59914 }
59915
59916
59917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59918   int jresult ;
59919   int result;
59920
59921   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59922   jresult = (int)result;
59923   return jresult;
59924 }
59925
59926
59927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59928   void * jresult ;
59929   Dali::Toolkit::Button::Property *result = 0 ;
59930
59931   {
59932     try {
59933       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (...) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59945       };
59946     }
59947   }
59948   jresult = (void *)result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59954   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59955
59956   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59957   {
59958     try {
59959       delete arg1;
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59967       };
59968     } catch (...) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59971       };
59972     }
59973   }
59974 }
59975
59976
59977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59978   void * jresult ;
59979   Dali::Toolkit::Button *result = 0 ;
59980
59981   {
59982     try {
59983       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59995       };
59996     }
59997   }
59998   jresult = (void *)result;
59999   return jresult;
60000 }
60001
60002
60003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60004   void * jresult ;
60005   Dali::Toolkit::Button *arg1 = 0 ;
60006   Dali::Toolkit::Button *result = 0 ;
60007
60008   arg1 = (Dali::Toolkit::Button *)jarg1;
60009   if (!arg1) {
60010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60011     return 0;
60012   }
60013   {
60014     try {
60015       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60016     } catch (std::out_of_range& e) {
60017       {
60018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60019       };
60020     } catch (std::exception& e) {
60021       {
60022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60023       };
60024     } catch (...) {
60025       {
60026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60027       };
60028     }
60029   }
60030   jresult = (void *)result;
60031   return jresult;
60032 }
60033
60034
60035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60036   void * jresult ;
60037   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60038   Dali::Toolkit::Button *arg2 = 0 ;
60039   Dali::Toolkit::Button *result = 0 ;
60040
60041   arg1 = (Dali::Toolkit::Button *)jarg1;
60042   arg2 = (Dali::Toolkit::Button *)jarg2;
60043   if (!arg2) {
60044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60045     return 0;
60046   }
60047   {
60048     try {
60049       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60050     } catch (std::out_of_range& e) {
60051       {
60052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60053       };
60054     } catch (std::exception& e) {
60055       {
60056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60057       };
60058     } catch (...) {
60059       {
60060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60061       };
60062     }
60063   }
60064   jresult = (void *)result;
60065   return jresult;
60066 }
60067
60068
60069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60070   void * jresult ;
60071   Dali::BaseHandle arg1 ;
60072   Dali::BaseHandle *argp1 ;
60073   Dali::Toolkit::Button result;
60074
60075   argp1 = (Dali::BaseHandle *)jarg1;
60076   if (!argp1) {
60077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60078     return 0;
60079   }
60080   arg1 = *argp1;
60081   {
60082     try {
60083       result = Dali::Toolkit::Button::DownCast(arg1);
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (...) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60095       };
60096     }
60097   }
60098   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60099   return jresult;
60100 }
60101
60102
60103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60105
60106   arg1 = (Dali::Toolkit::Button *)jarg1;
60107   {
60108     try {
60109       delete arg1;
60110     } catch (std::out_of_range& e) {
60111       {
60112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60113       };
60114     } catch (std::exception& e) {
60115       {
60116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60117       };
60118     } catch (...) {
60119       {
60120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60121       };
60122     }
60123   }
60124 }
60125
60126
60127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60128   unsigned int jresult ;
60129   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60130   bool result;
60131
60132   arg1 = (Dali::Toolkit::Button *)jarg1;
60133   {
60134     try {
60135       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60136     } catch (std::out_of_range& e) {
60137       {
60138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60139       };
60140     } catch (std::exception& e) {
60141       {
60142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60143       };
60144     } catch (...) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60147       };
60148     }
60149   }
60150   jresult = result;
60151   return jresult;
60152 }
60153
60154
60155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60156   unsigned int jresult ;
60157   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60158   bool result;
60159
60160   arg1 = (Dali::Toolkit::Button *)jarg1;
60161   {
60162     try {
60163       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60164     } catch (std::out_of_range& e) {
60165       {
60166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60167       };
60168     } catch (std::exception& e) {
60169       {
60170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60171       };
60172     } catch (...) {
60173       {
60174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60175       };
60176     }
60177   }
60178   jresult = result;
60179   return jresult;
60180 }
60181
60182
60183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60184   float jresult ;
60185   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60186   float result;
60187
60188   arg1 = (Dali::Toolkit::Button *)jarg1;
60189   {
60190     try {
60191       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60192     } catch (std::out_of_range& e) {
60193       {
60194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60195       };
60196     } catch (std::exception& e) {
60197       {
60198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60199       };
60200     } catch (...) {
60201       {
60202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60203       };
60204     }
60205   }
60206   jresult = result;
60207   return jresult;
60208 }
60209
60210
60211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60212   float jresult ;
60213   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60214   float result;
60215
60216   arg1 = (Dali::Toolkit::Button *)jarg1;
60217   {
60218     try {
60219       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60220     } catch (std::out_of_range& e) {
60221       {
60222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60223       };
60224     } catch (std::exception& e) {
60225       {
60226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60227       };
60228     } catch (...) {
60229       {
60230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60231       };
60232     }
60233   }
60234   jresult = result;
60235   return jresult;
60236 }
60237
60238
60239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60240   unsigned int jresult ;
60241   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60242   bool result;
60243
60244   arg1 = (Dali::Toolkit::Button *)jarg1;
60245   {
60246     try {
60247       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60248     } catch (std::out_of_range& e) {
60249       {
60250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (std::exception& e) {
60253       {
60254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (...) {
60257       {
60258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60259       };
60260     }
60261   }
60262   jresult = result;
60263   return jresult;
60264 }
60265
60266
60267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60268   unsigned int jresult ;
60269   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60270   bool result;
60271
60272   arg1 = (Dali::Toolkit::Button *)jarg1;
60273   {
60274     try {
60275       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60276     } catch (std::out_of_range& e) {
60277       {
60278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (std::exception& e) {
60281       {
60282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (...) {
60285       {
60286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60287       };
60288     }
60289   }
60290   jresult = result;
60291   return jresult;
60292 }
60293
60294
60295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60296   float jresult ;
60297   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60298   float result;
60299
60300   arg1 = (Dali::Toolkit::Button *)jarg1;
60301   {
60302     try {
60303       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60304     } catch (std::out_of_range& e) {
60305       {
60306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60307       };
60308     } catch (std::exception& e) {
60309       {
60310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60311       };
60312     } catch (...) {
60313       {
60314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60315       };
60316     }
60317   }
60318   jresult = result;
60319   return jresult;
60320 }
60321
60322
60323 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60324   char * jresult ;
60325   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60326   std::string result;
60327
60328   arg1 = (Dali::Toolkit::Button *)jarg1;
60329   {
60330     try {
60331       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60332     } catch (std::out_of_range& e) {
60333       {
60334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60335       };
60336     } catch (std::exception& e) {
60337       {
60338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60339       };
60340     } catch (...) {
60341       {
60342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60343       };
60344     }
60345   }
60346   jresult = SWIG_csharp_string_callback((&result)->c_str());
60347   return jresult;
60348 }
60349
60350
60351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60352   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60353   Dali::Actor arg2 ;
60354   Dali::Actor *argp2 ;
60355
60356   arg1 = (Dali::Toolkit::Button *)jarg1;
60357   argp2 = (Dali::Actor *)jarg2;
60358   if (!argp2) {
60359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60360     return ;
60361   }
60362   arg2 = *argp2;
60363   {
60364     try {
60365       (arg1)->SetLabel(arg2);
60366     } catch (std::out_of_range& e) {
60367       {
60368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60369       };
60370     } catch (std::exception& e) {
60371       {
60372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60373       };
60374     } catch (...) {
60375       {
60376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60377       };
60378     }
60379   }
60380 }
60381
60382
60383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60384   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60385   Dali::Image arg2 ;
60386   Dali::Image *argp2 ;
60387
60388   arg1 = (Dali::Toolkit::Button *)jarg1;
60389   argp2 = (Dali::Image *)jarg2;
60390   if (!argp2) {
60391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60392     return ;
60393   }
60394   arg2 = *argp2;
60395   {
60396     try {
60397       (arg1)->SetButtonImage(arg2);
60398     } catch (std::out_of_range& e) {
60399       {
60400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60401       };
60402     } catch (std::exception& e) {
60403       {
60404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60405       };
60406     } catch (...) {
60407       {
60408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60409       };
60410     }
60411   }
60412 }
60413
60414
60415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60417   Dali::Image arg2 ;
60418   Dali::Image *argp2 ;
60419
60420   arg1 = (Dali::Toolkit::Button *)jarg1;
60421   argp2 = (Dali::Image *)jarg2;
60422   if (!argp2) {
60423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60424     return ;
60425   }
60426   arg2 = *argp2;
60427   {
60428     try {
60429       (arg1)->SetSelectedImage(arg2);
60430     } catch (std::out_of_range& e) {
60431       {
60432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60433       };
60434     } catch (std::exception& e) {
60435       {
60436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60437       };
60438     } catch (...) {
60439       {
60440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60441       };
60442     }
60443   }
60444 }
60445
60446
60447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60448   void * jresult ;
60449   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60450   Dali::Actor result;
60451
60452   arg1 = (Dali::Toolkit::Button *)jarg1;
60453   {
60454     try {
60455       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60456     } catch (std::out_of_range& e) {
60457       {
60458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (std::exception& e) {
60461       {
60462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60463       };
60464     } catch (...) {
60465       {
60466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60467       };
60468     }
60469   }
60470   jresult = new Dali::Actor((const Dali::Actor &)result);
60471   return jresult;
60472 }
60473
60474
60475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60476   void * jresult ;
60477   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60478   Dali::Actor result;
60479
60480   arg1 = (Dali::Toolkit::Button *)jarg1;
60481   {
60482     try {
60483       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60484     } catch (std::out_of_range& e) {
60485       {
60486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60487       };
60488     } catch (std::exception& e) {
60489       {
60490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60491       };
60492     } catch (...) {
60493       {
60494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60495       };
60496     }
60497   }
60498   jresult = new Dali::Actor((const Dali::Actor &)result);
60499   return jresult;
60500 }
60501
60502
60503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60504   void * jresult ;
60505   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60506   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60507
60508   arg1 = (Dali::Toolkit::Button *)jarg1;
60509   {
60510     try {
60511       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60512     } catch (std::out_of_range& e) {
60513       {
60514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60515       };
60516     } catch (std::exception& e) {
60517       {
60518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (...) {
60521       {
60522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60523       };
60524     }
60525   }
60526   jresult = (void *)result;
60527   return jresult;
60528 }
60529
60530
60531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60532   void * jresult ;
60533   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60534   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60535
60536   arg1 = (Dali::Toolkit::Button *)jarg1;
60537   {
60538     try {
60539       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60540     } catch (std::out_of_range& e) {
60541       {
60542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60543       };
60544     } catch (std::exception& e) {
60545       {
60546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (...) {
60549       {
60550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60551       };
60552     }
60553   }
60554   jresult = (void *)result;
60555   return jresult;
60556 }
60557
60558
60559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60560   void * jresult ;
60561   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60562   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60563
60564   arg1 = (Dali::Toolkit::Button *)jarg1;
60565   {
60566     try {
60567       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60568     } catch (std::out_of_range& e) {
60569       {
60570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60571       };
60572     } catch (std::exception& e) {
60573       {
60574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60575       };
60576     } catch (...) {
60577       {
60578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60579       };
60580     }
60581   }
60582   jresult = (void *)result;
60583   return jresult;
60584 }
60585
60586
60587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60588   void * jresult ;
60589   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60590   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60591
60592   arg1 = (Dali::Toolkit::Button *)jarg1;
60593   {
60594     try {
60595       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60596     } catch (std::out_of_range& e) {
60597       {
60598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60599       };
60600     } catch (std::exception& e) {
60601       {
60602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60603       };
60604     } catch (...) {
60605       {
60606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60607       };
60608     }
60609   }
60610   jresult = (void *)result;
60611   return jresult;
60612 }
60613
60614
60615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60616   void * jresult ;
60617   Dali::Toolkit::CheckBoxButton *result = 0 ;
60618
60619   {
60620     try {
60621       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60622     } catch (std::out_of_range& e) {
60623       {
60624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60625       };
60626     } catch (std::exception& e) {
60627       {
60628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60629       };
60630     } catch (...) {
60631       {
60632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60633       };
60634     }
60635   }
60636   jresult = (void *)result;
60637   return jresult;
60638 }
60639
60640
60641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60642   void * jresult ;
60643   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60644   Dali::Toolkit::CheckBoxButton *result = 0 ;
60645
60646   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60647   if (!arg1) {
60648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60649     return 0;
60650   }
60651   {
60652     try {
60653       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60654     } catch (std::out_of_range& e) {
60655       {
60656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60657       };
60658     } catch (std::exception& e) {
60659       {
60660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60661       };
60662     } catch (...) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60665       };
60666     }
60667   }
60668   jresult = (void *)result;
60669   return jresult;
60670 }
60671
60672
60673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60674   void * jresult ;
60675   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60676   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60677   Dali::Toolkit::CheckBoxButton *result = 0 ;
60678
60679   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60680   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60681   if (!arg2) {
60682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60683     return 0;
60684   }
60685   {
60686     try {
60687       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60688     } catch (std::out_of_range& e) {
60689       {
60690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60691       };
60692     } catch (std::exception& e) {
60693       {
60694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60695       };
60696     } catch (...) {
60697       {
60698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60699       };
60700     }
60701   }
60702   jresult = (void *)result;
60703   return jresult;
60704 }
60705
60706
60707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60708   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60709
60710   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60711   {
60712     try {
60713       delete arg1;
60714     } catch (std::out_of_range& e) {
60715       {
60716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60717       };
60718     } catch (std::exception& e) {
60719       {
60720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60721       };
60722     } catch (...) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60725       };
60726     }
60727   }
60728 }
60729
60730
60731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60732   void * jresult ;
60733   Dali::Toolkit::CheckBoxButton result;
60734
60735   {
60736     try {
60737       result = Dali::Toolkit::CheckBoxButton::New();
60738     } catch (std::out_of_range& e) {
60739       {
60740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60741       };
60742     } catch (std::exception& e) {
60743       {
60744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60745       };
60746     } catch (...) {
60747       {
60748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60749       };
60750     }
60751   }
60752   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60753   return jresult;
60754 }
60755
60756
60757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60758   void * jresult ;
60759   Dali::BaseHandle arg1 ;
60760   Dali::BaseHandle *argp1 ;
60761   Dali::Toolkit::CheckBoxButton result;
60762
60763   argp1 = (Dali::BaseHandle *)jarg1;
60764   if (!argp1) {
60765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60766     return 0;
60767   }
60768   arg1 = *argp1;
60769   {
60770     try {
60771       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60772     } catch (std::out_of_range& e) {
60773       {
60774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (std::exception& e) {
60777       {
60778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60779       };
60780     } catch (...) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60783       };
60784     }
60785   }
60786   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60787   return jresult;
60788 }
60789
60790
60791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60792   int jresult ;
60793   int result;
60794
60795   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60796   jresult = (int)result;
60797   return jresult;
60798 }
60799
60800
60801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60802   int jresult ;
60803   int result;
60804
60805   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60806   jresult = (int)result;
60807   return jresult;
60808 }
60809
60810
60811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60812   int jresult ;
60813   int result;
60814
60815   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60816   jresult = (int)result;
60817   return jresult;
60818 }
60819
60820
60821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60822   int jresult ;
60823   int result;
60824
60825   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60826   jresult = (int)result;
60827   return jresult;
60828 }
60829
60830
60831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60832   int jresult ;
60833   int result;
60834
60835   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60836   jresult = (int)result;
60837   return jresult;
60838 }
60839
60840
60841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60842   void * jresult ;
60843   Dali::Toolkit::PushButton::Property *result = 0 ;
60844
60845   {
60846     try {
60847       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60848     } catch (std::out_of_range& e) {
60849       {
60850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60851       };
60852     } catch (std::exception& e) {
60853       {
60854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60855       };
60856     } catch (...) {
60857       {
60858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60859       };
60860     }
60861   }
60862   jresult = (void *)result;
60863   return jresult;
60864 }
60865
60866
60867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60868   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60869
60870   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60871   {
60872     try {
60873       delete arg1;
60874     } catch (std::out_of_range& e) {
60875       {
60876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60877       };
60878     } catch (std::exception& e) {
60879       {
60880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60881       };
60882     } catch (...) {
60883       {
60884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60885       };
60886     }
60887   }
60888 }
60889
60890
60891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60892   void * jresult ;
60893   Dali::Toolkit::PushButton *result = 0 ;
60894
60895   {
60896     try {
60897       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60898     } catch (std::out_of_range& e) {
60899       {
60900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60901       };
60902     } catch (std::exception& e) {
60903       {
60904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60909       };
60910     }
60911   }
60912   jresult = (void *)result;
60913   return jresult;
60914 }
60915
60916
60917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60918   void * jresult ;
60919   Dali::Toolkit::PushButton *arg1 = 0 ;
60920   Dali::Toolkit::PushButton *result = 0 ;
60921
60922   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60923   if (!arg1) {
60924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60925     return 0;
60926   }
60927   {
60928     try {
60929       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60941       };
60942     }
60943   }
60944   jresult = (void *)result;
60945   return jresult;
60946 }
60947
60948
60949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60950   void * jresult ;
60951   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60952   Dali::Toolkit::PushButton *arg2 = 0 ;
60953   Dali::Toolkit::PushButton *result = 0 ;
60954
60955   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60956   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60957   if (!arg2) {
60958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60959     return 0;
60960   }
60961   {
60962     try {
60963       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
60964     } catch (std::out_of_range& e) {
60965       {
60966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60967       };
60968     } catch (std::exception& e) {
60969       {
60970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60971       };
60972     } catch (...) {
60973       {
60974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60975       };
60976     }
60977   }
60978   jresult = (void *)result;
60979   return jresult;
60980 }
60981
60982
60983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
60984   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60985
60986   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60987   {
60988     try {
60989       delete arg1;
60990     } catch (std::out_of_range& e) {
60991       {
60992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60993       };
60994     } catch (std::exception& e) {
60995       {
60996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60997       };
60998     } catch (...) {
60999       {
61000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61001       };
61002     }
61003   }
61004 }
61005
61006
61007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
61008   void * jresult ;
61009   Dali::Toolkit::PushButton result;
61010
61011   {
61012     try {
61013       result = Dali::Toolkit::PushButton::New();
61014     } catch (std::out_of_range& e) {
61015       {
61016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (std::exception& e) {
61019       {
61020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61021       };
61022     } catch (...) {
61023       {
61024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61025       };
61026     }
61027   }
61028   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61029   return jresult;
61030 }
61031
61032
61033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61034   void * jresult ;
61035   Dali::BaseHandle arg1 ;
61036   Dali::BaseHandle *argp1 ;
61037   Dali::Toolkit::PushButton result;
61038
61039   argp1 = (Dali::BaseHandle *)jarg1;
61040   if (!argp1) {
61041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61042     return 0;
61043   }
61044   arg1 = *argp1;
61045   {
61046     try {
61047       result = Dali::Toolkit::PushButton::DownCast(arg1);
61048     } catch (std::out_of_range& e) {
61049       {
61050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61051       };
61052     } catch (std::exception& e) {
61053       {
61054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61055       };
61056     } catch (...) {
61057       {
61058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61059       };
61060     }
61061   }
61062   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61063   return jresult;
61064 }
61065
61066
61067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61068   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61069   Dali::Image arg2 ;
61070   Dali::Image *argp2 ;
61071
61072   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61073   argp2 = (Dali::Image *)jarg2;
61074   if (!argp2) {
61075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61076     return ;
61077   }
61078   arg2 = *argp2;
61079   {
61080     try {
61081       (arg1)->SetButtonImage(arg2);
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61093       };
61094     }
61095   }
61096 }
61097
61098
61099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61100   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61101   Dali::Actor arg2 ;
61102   Dali::Actor *argp2 ;
61103
61104   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61105   argp2 = (Dali::Actor *)jarg2;
61106   if (!argp2) {
61107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61108     return ;
61109   }
61110   arg2 = *argp2;
61111   {
61112     try {
61113       (arg1)->SetButtonImage(arg2);
61114     } catch (std::out_of_range& e) {
61115       {
61116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61117       };
61118     } catch (std::exception& e) {
61119       {
61120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61121       };
61122     } catch (...) {
61123       {
61124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61125       };
61126     }
61127   }
61128 }
61129
61130
61131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61132   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61133   Dali::Actor arg2 ;
61134   Dali::Actor *argp2 ;
61135
61136   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61137   argp2 = (Dali::Actor *)jarg2;
61138   if (!argp2) {
61139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61140     return ;
61141   }
61142   arg2 = *argp2;
61143   {
61144     try {
61145       (arg1)->SetBackgroundImage(arg2);
61146     } catch (std::out_of_range& e) {
61147       {
61148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61149       };
61150     } catch (std::exception& e) {
61151       {
61152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61153       };
61154     } catch (...) {
61155       {
61156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61157       };
61158     }
61159   }
61160 }
61161
61162
61163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61164   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61165   Dali::Image arg2 ;
61166   Dali::Image *argp2 ;
61167
61168   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61169   argp2 = (Dali::Image *)jarg2;
61170   if (!argp2) {
61171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61172     return ;
61173   }
61174   arg2 = *argp2;
61175   {
61176     try {
61177       (arg1)->SetSelectedImage(arg2);
61178     } catch (std::out_of_range& e) {
61179       {
61180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61181       };
61182     } catch (std::exception& e) {
61183       {
61184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61185       };
61186     } catch (...) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61189       };
61190     }
61191   }
61192 }
61193
61194
61195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61196   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61197   Dali::Actor arg2 ;
61198   Dali::Actor *argp2 ;
61199
61200   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61201   argp2 = (Dali::Actor *)jarg2;
61202   if (!argp2) {
61203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61204     return ;
61205   }
61206   arg2 = *argp2;
61207   {
61208     try {
61209       (arg1)->SetSelectedImage(arg2);
61210     } catch (std::out_of_range& e) {
61211       {
61212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61213       };
61214     } catch (std::exception& e) {
61215       {
61216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61217       };
61218     } catch (...) {
61219       {
61220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61221       };
61222     }
61223   }
61224 }
61225
61226
61227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61228   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61229   Dali::Actor arg2 ;
61230   Dali::Actor *argp2 ;
61231
61232   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61233   argp2 = (Dali::Actor *)jarg2;
61234   if (!argp2) {
61235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61236     return ;
61237   }
61238   arg2 = *argp2;
61239   {
61240     try {
61241       (arg1)->SetSelectedBackgroundImage(arg2);
61242     } catch (std::out_of_range& e) {
61243       {
61244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61245       };
61246     } catch (std::exception& e) {
61247       {
61248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61253       };
61254     }
61255   }
61256 }
61257
61258
61259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61260   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61261   Dali::Actor arg2 ;
61262   Dali::Actor *argp2 ;
61263
61264   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61265   argp2 = (Dali::Actor *)jarg2;
61266   if (!argp2) {
61267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61268     return ;
61269   }
61270   arg2 = *argp2;
61271   {
61272     try {
61273       (arg1)->SetDisabledBackgroundImage(arg2);
61274     } catch (std::out_of_range& e) {
61275       {
61276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61277       };
61278     } catch (std::exception& e) {
61279       {
61280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61281       };
61282     } catch (...) {
61283       {
61284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61285       };
61286     }
61287   }
61288 }
61289
61290
61291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61292   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61293   Dali::Actor arg2 ;
61294   Dali::Actor *argp2 ;
61295
61296   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61297   argp2 = (Dali::Actor *)jarg2;
61298   if (!argp2) {
61299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61300     return ;
61301   }
61302   arg2 = *argp2;
61303   {
61304     try {
61305       (arg1)->SetDisabledImage(arg2);
61306     } catch (std::out_of_range& e) {
61307       {
61308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61309       };
61310     } catch (std::exception& e) {
61311       {
61312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61313       };
61314     } catch (...) {
61315       {
61316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61317       };
61318     }
61319   }
61320 }
61321
61322
61323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61324   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61325   Dali::Actor arg2 ;
61326   Dali::Actor *argp2 ;
61327
61328   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61329   argp2 = (Dali::Actor *)jarg2;
61330   if (!argp2) {
61331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61332     return ;
61333   }
61334   arg2 = *argp2;
61335   {
61336     try {
61337       (arg1)->SetDisabledSelectedImage(arg2);
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61345       };
61346     } catch (...) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61349       };
61350     }
61351   }
61352 }
61353
61354
61355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61356   void * jresult ;
61357   Dali::Toolkit::RadioButton *result = 0 ;
61358
61359   {
61360     try {
61361       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61362     } catch (std::out_of_range& e) {
61363       {
61364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61365       };
61366     } catch (std::exception& e) {
61367       {
61368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61369       };
61370     } catch (...) {
61371       {
61372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61373       };
61374     }
61375   }
61376   jresult = (void *)result;
61377   return jresult;
61378 }
61379
61380
61381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61382   void * jresult ;
61383   Dali::Toolkit::RadioButton *arg1 = 0 ;
61384   Dali::Toolkit::RadioButton *result = 0 ;
61385
61386   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61387   if (!arg1) {
61388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61389     return 0;
61390   }
61391   {
61392     try {
61393       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61394     } catch (std::out_of_range& e) {
61395       {
61396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61397       };
61398     } catch (std::exception& e) {
61399       {
61400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61405       };
61406     }
61407   }
61408   jresult = (void *)result;
61409   return jresult;
61410 }
61411
61412
61413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61414   void * jresult ;
61415   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61416   Dali::Toolkit::RadioButton *arg2 = 0 ;
61417   Dali::Toolkit::RadioButton *result = 0 ;
61418
61419   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61420   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61421   if (!arg2) {
61422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61423     return 0;
61424   }
61425   {
61426     try {
61427       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61428     } catch (std::out_of_range& e) {
61429       {
61430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (std::exception& e) {
61433       {
61434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61435       };
61436     } catch (...) {
61437       {
61438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61439       };
61440     }
61441   }
61442   jresult = (void *)result;
61443   return jresult;
61444 }
61445
61446
61447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61448   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61449
61450   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61451   {
61452     try {
61453       delete arg1;
61454     } catch (std::out_of_range& e) {
61455       {
61456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61457       };
61458     } catch (std::exception& e) {
61459       {
61460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61461       };
61462     } catch (...) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61465       };
61466     }
61467   }
61468 }
61469
61470
61471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61472   void * jresult ;
61473   Dali::Toolkit::RadioButton result;
61474
61475   {
61476     try {
61477       result = Dali::Toolkit::RadioButton::New();
61478     } catch (std::out_of_range& e) {
61479       {
61480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61481       };
61482     } catch (std::exception& e) {
61483       {
61484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61485       };
61486     } catch (...) {
61487       {
61488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61489       };
61490     }
61491   }
61492   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61493   return jresult;
61494 }
61495
61496
61497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61498   void * jresult ;
61499   std::string *arg1 = 0 ;
61500   Dali::Toolkit::RadioButton result;
61501
61502   if (!jarg1) {
61503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61504     return 0;
61505   }
61506   std::string arg1_str(jarg1);
61507   arg1 = &arg1_str;
61508   {
61509     try {
61510       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61511     } catch (std::out_of_range& e) {
61512       {
61513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (std::exception& e) {
61516       {
61517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61526
61527   //argout typemap for const std::string&
61528
61529   return jresult;
61530 }
61531
61532
61533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61534   void * jresult ;
61535   Dali::BaseHandle arg1 ;
61536   Dali::BaseHandle *argp1 ;
61537   Dali::Toolkit::RadioButton result;
61538
61539   argp1 = (Dali::BaseHandle *)jarg1;
61540   if (!argp1) {
61541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61542     return 0;
61543   }
61544   arg1 = *argp1;
61545   {
61546     try {
61547       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61548     } catch (std::out_of_range& e) {
61549       {
61550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61551       };
61552     } catch (std::exception& e) {
61553       {
61554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61555       };
61556     } catch (...) {
61557       {
61558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61559       };
61560     }
61561   }
61562   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61563   return jresult;
61564 }
61565
61566
61567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61568   int jresult ;
61569   int result;
61570
61571   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61572   jresult = (int)result;
61573   return jresult;
61574 }
61575
61576
61577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61578   int jresult ;
61579   int result;
61580
61581   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61582   jresult = (int)result;
61583   return jresult;
61584 }
61585
61586
61587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61588   int jresult ;
61589   int result;
61590
61591   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61592   jresult = (int)result;
61593   return jresult;
61594 }
61595
61596
61597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61598   int jresult ;
61599   int result;
61600
61601   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61602   jresult = (int)result;
61603   return jresult;
61604 }
61605
61606
61607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61608   int jresult ;
61609   int result;
61610
61611   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61612   jresult = (int)result;
61613   return jresult;
61614 }
61615
61616
61617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61618   int jresult ;
61619   int result;
61620
61621   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61622   jresult = (int)result;
61623   return jresult;
61624 }
61625
61626
61627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61628   void * jresult ;
61629   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61630
61631   {
61632     try {
61633       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61634     } catch (std::out_of_range& e) {
61635       {
61636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61637       };
61638     } catch (std::exception& e) {
61639       {
61640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61641       };
61642     } catch (...) {
61643       {
61644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61645       };
61646     }
61647   }
61648   jresult = (void *)result;
61649   return jresult;
61650 }
61651
61652
61653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61654   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61655
61656   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61657   {
61658     try {
61659       delete arg1;
61660     } catch (std::out_of_range& e) {
61661       {
61662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61663       };
61664     } catch (std::exception& e) {
61665       {
61666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61667       };
61668     } catch (...) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61671       };
61672     }
61673   }
61674 }
61675
61676
61677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61678   int jresult ;
61679   int result;
61680
61681   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61682   jresult = (int)result;
61683   return jresult;
61684 }
61685
61686
61687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61688   int jresult ;
61689   int result;
61690
61691   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61692   jresult = (int)result;
61693   return jresult;
61694 }
61695
61696
61697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61698   int jresult ;
61699   int result;
61700
61701   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61702   jresult = (int)result;
61703   return jresult;
61704 }
61705
61706
61707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61708   void * jresult ;
61709   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61710
61711   {
61712     try {
61713       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61714     } catch (std::out_of_range& e) {
61715       {
61716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61717       };
61718     } catch (std::exception& e) {
61719       {
61720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61721       };
61722     } catch (...) {
61723       {
61724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61725       };
61726     }
61727   }
61728   jresult = (void *)result;
61729   return jresult;
61730 }
61731
61732
61733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61734   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61735
61736   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61737   {
61738     try {
61739       delete arg1;
61740     } catch (std::out_of_range& e) {
61741       {
61742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61743       };
61744     } catch (std::exception& e) {
61745       {
61746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61751       };
61752     }
61753   }
61754 }
61755
61756
61757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61758   void * jresult ;
61759   Dali::Toolkit::FlexContainer *result = 0 ;
61760
61761   {
61762     try {
61763       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61764     } catch (std::out_of_range& e) {
61765       {
61766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61767       };
61768     } catch (std::exception& e) {
61769       {
61770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61771       };
61772     } catch (...) {
61773       {
61774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61775       };
61776     }
61777   }
61778   jresult = (void *)result;
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61784   void * jresult ;
61785   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61786   Dali::Toolkit::FlexContainer *result = 0 ;
61787
61788   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61789   if (!arg1) {
61790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61791     return 0;
61792   }
61793   {
61794     try {
61795       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61796     } catch (std::out_of_range& e) {
61797       {
61798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61799       };
61800     } catch (std::exception& e) {
61801       {
61802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (...) {
61805       {
61806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61807       };
61808     }
61809   }
61810   jresult = (void *)result;
61811   return jresult;
61812 }
61813
61814
61815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61816   void * jresult ;
61817   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61818   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61819   Dali::Toolkit::FlexContainer *result = 0 ;
61820
61821   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61822   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61823   if (!arg2) {
61824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61825     return 0;
61826   }
61827   {
61828     try {
61829       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61830     } catch (std::out_of_range& e) {
61831       {
61832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61833       };
61834     } catch (std::exception& e) {
61835       {
61836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61837       };
61838     } catch (...) {
61839       {
61840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61841       };
61842     }
61843   }
61844   jresult = (void *)result;
61845   return jresult;
61846 }
61847
61848
61849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61850   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61851
61852   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61853   {
61854     try {
61855       delete arg1;
61856     } catch (std::out_of_range& e) {
61857       {
61858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61859       };
61860     } catch (std::exception& e) {
61861       {
61862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61867       };
61868     }
61869   }
61870 }
61871
61872
61873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61874   void * jresult ;
61875   Dali::Toolkit::FlexContainer result;
61876
61877   {
61878     try {
61879       result = Dali::Toolkit::FlexContainer::New();
61880     } catch (std::out_of_range& e) {
61881       {
61882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61883       };
61884     } catch (std::exception& e) {
61885       {
61886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61887       };
61888     } catch (...) {
61889       {
61890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61891       };
61892     }
61893   }
61894   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61895   return jresult;
61896 }
61897
61898
61899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61900   void * jresult ;
61901   Dali::BaseHandle arg1 ;
61902   Dali::BaseHandle *argp1 ;
61903   Dali::Toolkit::FlexContainer result;
61904
61905   argp1 = (Dali::BaseHandle *)jarg1;
61906   if (!argp1) {
61907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61908     return 0;
61909   }
61910   arg1 = *argp1;
61911   {
61912     try {
61913       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61914     } catch (std::out_of_range& e) {
61915       {
61916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61917       };
61918     } catch (std::exception& e) {
61919       {
61920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61921       };
61922     } catch (...) {
61923       {
61924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61925       };
61926     }
61927   }
61928   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61929   return jresult;
61930 }
61931
61932
61933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61934   int jresult ;
61935   int result;
61936
61937   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61938   jresult = (int)result;
61939   return jresult;
61940 }
61941
61942
61943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61944   int jresult ;
61945   int result;
61946
61947   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61948   jresult = (int)result;
61949   return jresult;
61950 }
61951
61952
61953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61954   int jresult ;
61955   int result;
61956
61957   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61958   jresult = (int)result;
61959   return jresult;
61960 }
61961
61962
61963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61964   int jresult ;
61965   int result;
61966
61967   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61968   jresult = (int)result;
61969   return jresult;
61970 }
61971
61972
61973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61974   void * jresult ;
61975   Dali::Toolkit::ImageView::Property *result = 0 ;
61976
61977   {
61978     try {
61979       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
61980     } catch (std::out_of_range& e) {
61981       {
61982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61983       };
61984     } catch (std::exception& e) {
61985       {
61986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61987       };
61988     } catch (...) {
61989       {
61990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61991       };
61992     }
61993   }
61994   jresult = (void *)result;
61995   return jresult;
61996 }
61997
61998
61999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
62000   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
62001
62002   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62003   {
62004     try {
62005       delete arg1;
62006     } catch (std::out_of_range& e) {
62007       {
62008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62009       };
62010     } catch (std::exception& e) {
62011       {
62012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62013       };
62014     } catch (...) {
62015       {
62016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62017       };
62018     }
62019   }
62020 }
62021
62022
62023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62024   void * jresult ;
62025   Dali::Toolkit::ImageView *result = 0 ;
62026
62027   {
62028     try {
62029       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62030     } catch (std::out_of_range& e) {
62031       {
62032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62033       };
62034     } catch (std::exception& e) {
62035       {
62036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62037       };
62038     } catch (...) {
62039       {
62040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62041       };
62042     }
62043   }
62044   jresult = (void *)result;
62045   return jresult;
62046 }
62047
62048
62049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62050   void * jresult ;
62051   Dali::Toolkit::ImageView result;
62052
62053   {
62054     try {
62055       result = Dali::Toolkit::ImageView::New();
62056     } catch (std::out_of_range& e) {
62057       {
62058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62059       };
62060     } catch (std::exception& e) {
62061       {
62062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62063       };
62064     } catch (...) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62067       };
62068     }
62069   }
62070   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62071   return jresult;
62072 }
62073
62074
62075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62076   void * jresult ;
62077   Dali::Image arg1 ;
62078   Dali::Image *argp1 ;
62079   Dali::Toolkit::ImageView result;
62080
62081   argp1 = (Dali::Image *)jarg1;
62082   if (!argp1) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62084     return 0;
62085   }
62086   arg1 = *argp1;
62087   {
62088     try {
62089       result = Dali::Toolkit::ImageView::New(arg1);
62090     } catch (std::out_of_range& e) {
62091       {
62092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (std::exception& e) {
62095       {
62096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62097       };
62098     } catch (...) {
62099       {
62100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62101       };
62102     }
62103   }
62104   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62105   return jresult;
62106 }
62107
62108
62109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62110   void * jresult ;
62111   std::string *arg1 = 0 ;
62112   Dali::Toolkit::ImageView result;
62113
62114   if (!jarg1) {
62115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62116     return 0;
62117   }
62118   std::string arg1_str(jarg1);
62119   arg1 = &arg1_str;
62120   {
62121     try {
62122       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62123     } catch (std::out_of_range& e) {
62124       {
62125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62126       };
62127     } catch (std::exception& e) {
62128       {
62129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62130       };
62131     } catch (...) {
62132       {
62133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62134       };
62135     }
62136   }
62137   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62138
62139   //argout typemap for const std::string&
62140
62141   return jresult;
62142 }
62143
62144
62145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62146   void * jresult ;
62147   std::string *arg1 = 0 ;
62148   Dali::ImageDimensions arg2 ;
62149   Dali::ImageDimensions *argp2 ;
62150   Dali::Toolkit::ImageView result;
62151
62152   if (!jarg1) {
62153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62154     return 0;
62155   }
62156   std::string arg1_str(jarg1);
62157   arg1 = &arg1_str;
62158   argp2 = (Dali::ImageDimensions *)jarg2;
62159   if (!argp2) {
62160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62161     return 0;
62162   }
62163   arg2 = *argp2;
62164   {
62165     try {
62166       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62167     } catch (std::out_of_range& e) {
62168       {
62169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62170       };
62171     } catch (std::exception& e) {
62172       {
62173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62174       };
62175     } catch (...) {
62176       {
62177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62178       };
62179     }
62180   }
62181   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62182
62183   //argout typemap for const std::string&
62184
62185   return jresult;
62186 }
62187
62188
62189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62190   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62191
62192   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62193   {
62194     try {
62195       delete arg1;
62196     } catch (std::out_of_range& e) {
62197       {
62198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62199       };
62200     } catch (std::exception& e) {
62201       {
62202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62203       };
62204     } catch (...) {
62205       {
62206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62207       };
62208     }
62209   }
62210 }
62211
62212
62213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62214   void * jresult ;
62215   Dali::Toolkit::ImageView *arg1 = 0 ;
62216   Dali::Toolkit::ImageView *result = 0 ;
62217
62218   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62219   if (!arg1) {
62220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62221     return 0;
62222   }
62223   {
62224     try {
62225       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62226     } catch (std::out_of_range& e) {
62227       {
62228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (std::exception& e) {
62231       {
62232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240   jresult = (void *)result;
62241   return jresult;
62242 }
62243
62244
62245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62246   void * jresult ;
62247   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62248   Dali::Toolkit::ImageView *arg2 = 0 ;
62249   Dali::Toolkit::ImageView *result = 0 ;
62250
62251   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62252   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62253   if (!arg2) {
62254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62255     return 0;
62256   }
62257   {
62258     try {
62259       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62260     } catch (std::out_of_range& e) {
62261       {
62262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62263       };
62264     } catch (std::exception& e) {
62265       {
62266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62267       };
62268     } catch (...) {
62269       {
62270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62271       };
62272     }
62273   }
62274   jresult = (void *)result;
62275   return jresult;
62276 }
62277
62278
62279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62280   void * jresult ;
62281   Dali::BaseHandle arg1 ;
62282   Dali::BaseHandle *argp1 ;
62283   Dali::Toolkit::ImageView result;
62284
62285   argp1 = (Dali::BaseHandle *)jarg1;
62286   if (!argp1) {
62287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62288     return 0;
62289   }
62290   arg1 = *argp1;
62291   {
62292     try {
62293       result = Dali::Toolkit::ImageView::DownCast(arg1);
62294     } catch (std::out_of_range& e) {
62295       {
62296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62297       };
62298     } catch (std::exception& e) {
62299       {
62300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62301       };
62302     } catch (...) {
62303       {
62304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62305       };
62306     }
62307   }
62308   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62309   return jresult;
62310 }
62311
62312
62313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62314   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62315   Dali::Image arg2 ;
62316   Dali::Image *argp2 ;
62317
62318   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62319   argp2 = (Dali::Image *)jarg2;
62320   if (!argp2) {
62321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62322     return ;
62323   }
62324   arg2 = *argp2;
62325   {
62326     try {
62327       (arg1)->SetImage(arg2);
62328     } catch (std::out_of_range& e) {
62329       {
62330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62331       };
62332     } catch (std::exception& e) {
62333       {
62334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62335       };
62336     } catch (...) {
62337       {
62338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62339       };
62340     }
62341   }
62342 }
62343
62344
62345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62346   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62347   std::string *arg2 = 0 ;
62348
62349   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62350   if (!jarg2) {
62351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62352     return ;
62353   }
62354   std::string arg2_str(jarg2);
62355   arg2 = &arg2_str;
62356   {
62357     try {
62358       (arg1)->SetImage((std::string const &)*arg2);
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62370       };
62371     }
62372   }
62373
62374   //argout typemap for const std::string&
62375
62376 }
62377
62378
62379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62380   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62381   std::string *arg2 = 0 ;
62382   Dali::ImageDimensions arg3 ;
62383   Dali::ImageDimensions *argp3 ;
62384
62385   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62386   if (!jarg2) {
62387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62388     return ;
62389   }
62390   std::string arg2_str(jarg2);
62391   arg2 = &arg2_str;
62392   argp3 = (Dali::ImageDimensions *)jarg3;
62393   if (!argp3) {
62394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62395     return ;
62396   }
62397   arg3 = *argp3;
62398   {
62399     try {
62400       (arg1)->SetImage((std::string const &)*arg2,arg3);
62401     } catch (std::out_of_range& e) {
62402       {
62403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62404       };
62405     } catch (std::exception& e) {
62406       {
62407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62408       };
62409     } catch (...) {
62410       {
62411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62412       };
62413     }
62414   }
62415
62416   //argout typemap for const std::string&
62417
62418 }
62419
62420
62421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62422   void * jresult ;
62423   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62424   Dali::Image result;
62425
62426   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62427   {
62428     try {
62429       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62430     } catch (std::out_of_range& e) {
62431       {
62432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (std::exception& e) {
62435       {
62436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (...) {
62439       {
62440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62441       };
62442     }
62443   }
62444   jresult = new Dali::Image((const Dali::Image &)result);
62445   return jresult;
62446 }
62447
62448
62449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62450   int jresult ;
62451   int result;
62452
62453   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62454   jresult = (int)result;
62455   return jresult;
62456 }
62457
62458
62459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62460   int jresult ;
62461   int result;
62462
62463   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62464   jresult = (int)result;
62465   return jresult;
62466 }
62467
62468
62469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62470   int jresult ;
62471   int result;
62472
62473   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62474   jresult = (int)result;
62475   return jresult;
62476 }
62477
62478
62479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62480   int jresult ;
62481   int result;
62482
62483   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62484   jresult = (int)result;
62485   return jresult;
62486 }
62487
62488
62489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62490   int jresult ;
62491   int result;
62492
62493   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62494   jresult = (int)result;
62495   return jresult;
62496 }
62497
62498
62499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62500   int jresult ;
62501   int result;
62502
62503   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62504   jresult = (int)result;
62505   return jresult;
62506 }
62507
62508
62509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62510   int jresult ;
62511   int result;
62512
62513   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62514   jresult = (int)result;
62515   return jresult;
62516 }
62517
62518
62519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62520   int jresult ;
62521   int result;
62522
62523   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62524   jresult = (int)result;
62525   return jresult;
62526 }
62527
62528
62529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62530   void * jresult ;
62531   Dali::Toolkit::Model3dView::Property *result = 0 ;
62532
62533   {
62534     try {
62535       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62536     } catch (std::out_of_range& e) {
62537       {
62538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (std::exception& e) {
62541       {
62542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550   jresult = (void *)result;
62551   return jresult;
62552 }
62553
62554
62555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62556   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62557
62558   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62559   {
62560     try {
62561       delete arg1;
62562     } catch (std::out_of_range& e) {
62563       {
62564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62565       };
62566     } catch (std::exception& e) {
62567       {
62568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62569       };
62570     } catch (...) {
62571       {
62572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62573       };
62574     }
62575   }
62576 }
62577
62578
62579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62580   void * jresult ;
62581   Dali::Toolkit::Model3dView result;
62582
62583   {
62584     try {
62585       result = Dali::Toolkit::Model3dView::New();
62586     } catch (std::out_of_range& e) {
62587       {
62588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62589       };
62590     } catch (std::exception& e) {
62591       {
62592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62593       };
62594     } catch (...) {
62595       {
62596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62597       };
62598     }
62599   }
62600   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62601   return jresult;
62602 }
62603
62604
62605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62606   void * jresult ;
62607   std::string *arg1 = 0 ;
62608   std::string *arg2 = 0 ;
62609   std::string *arg3 = 0 ;
62610   Dali::Toolkit::Model3dView result;
62611
62612   if (!jarg1) {
62613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62614     return 0;
62615   }
62616   std::string arg1_str(jarg1);
62617   arg1 = &arg1_str;
62618   if (!jarg2) {
62619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62620     return 0;
62621   }
62622   std::string arg2_str(jarg2);
62623   arg2 = &arg2_str;
62624   if (!jarg3) {
62625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62626     return 0;
62627   }
62628   std::string arg3_str(jarg3);
62629   arg3 = &arg3_str;
62630   {
62631     try {
62632       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62633     } catch (std::out_of_range& e) {
62634       {
62635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62636       };
62637     } catch (std::exception& e) {
62638       {
62639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62640       };
62641     } catch (...) {
62642       {
62643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62644       };
62645     }
62646   }
62647   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62648
62649   //argout typemap for const std::string&
62650
62651
62652   //argout typemap for const std::string&
62653
62654
62655   //argout typemap for const std::string&
62656
62657   return jresult;
62658 }
62659
62660
62661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62662   void * jresult ;
62663   Dali::Toolkit::Model3dView *result = 0 ;
62664
62665   {
62666     try {
62667       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62668     } catch (std::out_of_range& e) {
62669       {
62670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62671       };
62672     } catch (std::exception& e) {
62673       {
62674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62675       };
62676     } catch (...) {
62677       {
62678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62679       };
62680     }
62681   }
62682   jresult = (void *)result;
62683   return jresult;
62684 }
62685
62686
62687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62688   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62689
62690   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62691   {
62692     try {
62693       delete arg1;
62694     } catch (std::out_of_range& e) {
62695       {
62696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62697       };
62698     } catch (std::exception& e) {
62699       {
62700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62701       };
62702     } catch (...) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62705       };
62706     }
62707   }
62708 }
62709
62710
62711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62712   void * jresult ;
62713   Dali::Toolkit::Model3dView *arg1 = 0 ;
62714   Dali::Toolkit::Model3dView *result = 0 ;
62715
62716   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62717   if (!arg1) {
62718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62719     return 0;
62720   }
62721   {
62722     try {
62723       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62724     } catch (std::out_of_range& e) {
62725       {
62726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62727       };
62728     } catch (std::exception& e) {
62729       {
62730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62731       };
62732     } catch (...) {
62733       {
62734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62735       };
62736     }
62737   }
62738   jresult = (void *)result;
62739   return jresult;
62740 }
62741
62742
62743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62744   void * jresult ;
62745   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62746   Dali::Toolkit::Model3dView *arg2 = 0 ;
62747   Dali::Toolkit::Model3dView *result = 0 ;
62748
62749   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62750   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62751   if (!arg2) {
62752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62753     return 0;
62754   }
62755   {
62756     try {
62757       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62758     } catch (std::out_of_range& e) {
62759       {
62760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (std::exception& e) {
62763       {
62764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62765       };
62766     } catch (...) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62769       };
62770     }
62771   }
62772   jresult = (void *)result;
62773   return jresult;
62774 }
62775
62776
62777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62778   void * jresult ;
62779   Dali::BaseHandle arg1 ;
62780   Dali::BaseHandle *argp1 ;
62781   Dali::Toolkit::Model3dView result;
62782
62783   argp1 = (Dali::BaseHandle *)jarg1;
62784   if (!argp1) {
62785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62786     return 0;
62787   }
62788   arg1 = *argp1;
62789   {
62790     try {
62791       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62792     } catch (std::out_of_range& e) {
62793       {
62794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (std::exception& e) {
62797       {
62798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (...) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62803       };
62804     }
62805   }
62806   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62807   return jresult;
62808 }
62809
62810
62811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62812   int jresult ;
62813   int result;
62814
62815   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62816   jresult = (int)result;
62817   return jresult;
62818 }
62819
62820
62821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62822   int jresult ;
62823   int result;
62824
62825   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62826   jresult = (int)result;
62827   return jresult;
62828 }
62829
62830
62831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62832   int jresult ;
62833   int result;
62834
62835   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62836   jresult = (int)result;
62837   return jresult;
62838 }
62839
62840
62841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62842   int jresult ;
62843   int result;
62844
62845   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62846   jresult = (int)result;
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62852   int jresult ;
62853   int result;
62854
62855   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62856   jresult = (int)result;
62857   return jresult;
62858 }
62859
62860
62861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62862   int jresult ;
62863   int result;
62864
62865   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62866   jresult = (int)result;
62867   return jresult;
62868 }
62869
62870
62871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62872   int jresult ;
62873   int result;
62874
62875   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62876   jresult = (int)result;
62877   return jresult;
62878 }
62879
62880
62881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62882   int jresult ;
62883   int result;
62884
62885   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62886   jresult = (int)result;
62887   return jresult;
62888 }
62889
62890
62891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62892   int jresult ;
62893   int result;
62894
62895   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62896   jresult = (int)result;
62897   return jresult;
62898 }
62899
62900
62901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62902   void * jresult ;
62903   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62904
62905   {
62906     try {
62907       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
62908     } catch (std::out_of_range& e) {
62909       {
62910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (std::exception& e) {
62913       {
62914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62915       };
62916     } catch (...) {
62917       {
62918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62919       };
62920     }
62921   }
62922   jresult = (void *)result;
62923   return jresult;
62924 }
62925
62926
62927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
62928   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62929
62930   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62931   {
62932     try {
62933       delete arg1;
62934     } catch (std::out_of_range& e) {
62935       {
62936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62937       };
62938     } catch (std::exception& e) {
62939       {
62940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62941       };
62942     } catch (...) {
62943       {
62944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62945       };
62946     }
62947   }
62948 }
62949
62950
62951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62952   void * jresult ;
62953   Dali::Toolkit::ScrollBar *result = 0 ;
62954
62955   {
62956     try {
62957       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62958     } catch (std::out_of_range& e) {
62959       {
62960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62961       };
62962     } catch (std::exception& e) {
62963       {
62964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62965       };
62966     } catch (...) {
62967       {
62968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62969       };
62970     }
62971   }
62972   jresult = (void *)result;
62973   return jresult;
62974 }
62975
62976
62977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62978   void * jresult ;
62979   Dali::Toolkit::ScrollBar *arg1 = 0 ;
62980   Dali::Toolkit::ScrollBar *result = 0 ;
62981
62982   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62983   if (!arg1) {
62984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62985     return 0;
62986   }
62987   {
62988     try {
62989       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
62990     } catch (std::out_of_range& e) {
62991       {
62992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62993       };
62994     } catch (std::exception& e) {
62995       {
62996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62997       };
62998     } catch (...) {
62999       {
63000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63001       };
63002     }
63003   }
63004   jresult = (void *)result;
63005   return jresult;
63006 }
63007
63008
63009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63010   void * jresult ;
63011   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63012   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63013   Dali::Toolkit::ScrollBar *result = 0 ;
63014
63015   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63016   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63017   if (!arg2) {
63018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63019     return 0;
63020   }
63021   {
63022     try {
63023       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63024     } catch (std::out_of_range& e) {
63025       {
63026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63027       };
63028     } catch (std::exception& e) {
63029       {
63030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63031       };
63032     } catch (...) {
63033       {
63034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63035       };
63036     }
63037   }
63038   jresult = (void *)result;
63039   return jresult;
63040 }
63041
63042
63043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63044   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63045
63046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63047   {
63048     try {
63049       delete arg1;
63050     } catch (std::out_of_range& e) {
63051       {
63052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63053       };
63054     } catch (std::exception& e) {
63055       {
63056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63057       };
63058     } catch (...) {
63059       {
63060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63061       };
63062     }
63063   }
63064 }
63065
63066
63067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63068   void * jresult ;
63069   Dali::Toolkit::ScrollBar::Direction arg1 ;
63070   Dali::Toolkit::ScrollBar result;
63071
63072   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63073   {
63074     try {
63075       result = Dali::Toolkit::ScrollBar::New(arg1);
63076     } catch (std::out_of_range& e) {
63077       {
63078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63079       };
63080     } catch (std::exception& e) {
63081       {
63082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63083       };
63084     } catch (...) {
63085       {
63086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63087       };
63088     }
63089   }
63090   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63091   return jresult;
63092 }
63093
63094
63095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63096   void * jresult ;
63097   Dali::Toolkit::ScrollBar result;
63098
63099   {
63100     try {
63101       result = Dali::Toolkit::ScrollBar::New();
63102     } catch (std::out_of_range& e) {
63103       {
63104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63105       };
63106     } catch (std::exception& e) {
63107       {
63108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63109       };
63110     } catch (...) {
63111       {
63112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63113       };
63114     }
63115   }
63116   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63117   return jresult;
63118 }
63119
63120
63121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63122   void * jresult ;
63123   Dali::BaseHandle arg1 ;
63124   Dali::BaseHandle *argp1 ;
63125   Dali::Toolkit::ScrollBar result;
63126
63127   argp1 = (Dali::BaseHandle *)jarg1;
63128   if (!argp1) {
63129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63130     return 0;
63131   }
63132   arg1 = *argp1;
63133   {
63134     try {
63135       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63143       };
63144     } catch (...) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63147       };
63148     }
63149   }
63150   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63151   return jresult;
63152 }
63153
63154
63155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63156   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63157   Dali::Handle arg2 ;
63158   Dali::Property::Index arg3 ;
63159   Dali::Property::Index arg4 ;
63160   Dali::Property::Index arg5 ;
63161   Dali::Property::Index arg6 ;
63162   Dali::Handle *argp2 ;
63163
63164   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63165   argp2 = (Dali::Handle *)jarg2;
63166   if (!argp2) {
63167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63168     return ;
63169   }
63170   arg2 = *argp2;
63171   arg3 = (Dali::Property::Index)jarg3;
63172   arg4 = (Dali::Property::Index)jarg4;
63173   arg5 = (Dali::Property::Index)jarg5;
63174   arg6 = (Dali::Property::Index)jarg6;
63175   {
63176     try {
63177       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (...) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63189       };
63190     }
63191   }
63192 }
63193
63194
63195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63196   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63197   Dali::Actor arg2 ;
63198   Dali::Actor *argp2 ;
63199
63200   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63201   argp2 = (Dali::Actor *)jarg2;
63202   if (!argp2) {
63203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63204     return ;
63205   }
63206   arg2 = *argp2;
63207   {
63208     try {
63209       (arg1)->SetScrollIndicator(arg2);
63210     } catch (std::out_of_range& e) {
63211       {
63212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63213       };
63214     } catch (std::exception& e) {
63215       {
63216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (...) {
63219       {
63220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63221       };
63222     }
63223   }
63224 }
63225
63226
63227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63228   void * jresult ;
63229   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63230   Dali::Actor result;
63231
63232   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63233   {
63234     try {
63235       result = (arg1)->GetScrollIndicator();
63236     } catch (std::out_of_range& e) {
63237       {
63238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63239       };
63240     } catch (std::exception& e) {
63241       {
63242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63243       };
63244     } catch (...) {
63245       {
63246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63247       };
63248     }
63249   }
63250   jresult = new Dali::Actor((const Dali::Actor &)result);
63251   return jresult;
63252 }
63253
63254
63255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63256   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63257   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63258
63259   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63260   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63261   if (!arg2) {
63262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63263     return ;
63264   }
63265   {
63266     try {
63267       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63268     } catch (std::out_of_range& e) {
63269       {
63270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63271       };
63272     } catch (std::exception& e) {
63273       {
63274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63275       };
63276     } catch (...) {
63277       {
63278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63279       };
63280     }
63281   }
63282 }
63283
63284
63285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63286   void * jresult ;
63287   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63288   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63289
63290   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63291   {
63292     try {
63293       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63294     } catch (std::out_of_range& e) {
63295       {
63296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63297       };
63298     } catch (std::exception& e) {
63299       {
63300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63301       };
63302     } catch (...) {
63303       {
63304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63305       };
63306     }
63307   }
63308   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63309   return jresult;
63310 }
63311
63312
63313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63314   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63315   Dali::Toolkit::ScrollBar::Direction arg2 ;
63316
63317   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63318   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63319   {
63320     try {
63321       (arg1)->SetScrollDirection(arg2);
63322     } catch (std::out_of_range& e) {
63323       {
63324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63325       };
63326     } catch (std::exception& e) {
63327       {
63328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63329       };
63330     } catch (...) {
63331       {
63332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63333       };
63334     }
63335   }
63336 }
63337
63338
63339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63340   int jresult ;
63341   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63342   Dali::Toolkit::ScrollBar::Direction result;
63343
63344   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63345   {
63346     try {
63347       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63348     } catch (std::out_of_range& e) {
63349       {
63350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (std::exception& e) {
63353       {
63354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63355       };
63356     } catch (...) {
63357       {
63358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63359       };
63360     }
63361   }
63362   jresult = (int)result;
63363   return jresult;
63364 }
63365
63366
63367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63368   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63369   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63370
63371   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63372   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63373   {
63374     try {
63375       (arg1)->SetIndicatorHeightPolicy(arg2);
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63387       };
63388     }
63389   }
63390 }
63391
63392
63393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63394   int jresult ;
63395   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63396   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63397
63398   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63399   {
63400     try {
63401       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63402     } catch (std::out_of_range& e) {
63403       {
63404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63405       };
63406     } catch (std::exception& e) {
63407       {
63408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63409       };
63410     } catch (...) {
63411       {
63412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63413       };
63414     }
63415   }
63416   jresult = (int)result;
63417   return jresult;
63418 }
63419
63420
63421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63422   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63423   float arg2 ;
63424
63425   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63426   arg2 = (float)jarg2;
63427   {
63428     try {
63429       (arg1)->SetIndicatorFixedHeight(arg2);
63430     } catch (std::out_of_range& e) {
63431       {
63432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63433       };
63434     } catch (std::exception& e) {
63435       {
63436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63437       };
63438     } catch (...) {
63439       {
63440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63441       };
63442     }
63443   }
63444 }
63445
63446
63447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63448   float jresult ;
63449   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63450   float result;
63451
63452   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63453   {
63454     try {
63455       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63456     } catch (std::out_of_range& e) {
63457       {
63458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63459       };
63460     } catch (std::exception& e) {
63461       {
63462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63463       };
63464     } catch (...) {
63465       {
63466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63467       };
63468     }
63469   }
63470   jresult = result;
63471   return jresult;
63472 }
63473
63474
63475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63476   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63477   float arg2 ;
63478
63479   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63480   arg2 = (float)jarg2;
63481   {
63482     try {
63483       (arg1)->SetIndicatorShowDuration(arg2);
63484     } catch (std::out_of_range& e) {
63485       {
63486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63487       };
63488     } catch (std::exception& e) {
63489       {
63490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63491       };
63492     } catch (...) {
63493       {
63494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63495       };
63496     }
63497   }
63498 }
63499
63500
63501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63502   float jresult ;
63503   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63504   float result;
63505
63506   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63507   {
63508     try {
63509       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63510     } catch (std::out_of_range& e) {
63511       {
63512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63513       };
63514     } catch (std::exception& e) {
63515       {
63516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63517       };
63518     } catch (...) {
63519       {
63520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63521       };
63522     }
63523   }
63524   jresult = result;
63525   return jresult;
63526 }
63527
63528
63529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63530   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63531   float arg2 ;
63532
63533   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63534   arg2 = (float)jarg2;
63535   {
63536     try {
63537       (arg1)->SetIndicatorHideDuration(arg2);
63538     } catch (std::out_of_range& e) {
63539       {
63540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (std::exception& e) {
63543       {
63544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (...) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63549       };
63550     }
63551   }
63552 }
63553
63554
63555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63556   float jresult ;
63557   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63558   float result;
63559
63560   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63561   {
63562     try {
63563       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63564     } catch (std::out_of_range& e) {
63565       {
63566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63567       };
63568     } catch (std::exception& e) {
63569       {
63570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63571       };
63572     } catch (...) {
63573       {
63574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63575       };
63576     }
63577   }
63578   jresult = result;
63579   return jresult;
63580 }
63581
63582
63583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63584   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63585
63586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63587   {
63588     try {
63589       (arg1)->ShowIndicator();
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_HideIndicator(void * jarg1) {
63608   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63609
63610   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63611   {
63612     try {
63613       (arg1)->HideIndicator();
63614     } catch (std::out_of_range& e) {
63615       {
63616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63617       };
63618     } catch (std::exception& e) {
63619       {
63620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63621       };
63622     } catch (...) {
63623       {
63624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63625       };
63626     }
63627   }
63628 }
63629
63630
63631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63632   void * jresult ;
63633   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63634   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63635
63636   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63637   {
63638     try {
63639       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63640     } catch (std::out_of_range& e) {
63641       {
63642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63643       };
63644     } catch (std::exception& e) {
63645       {
63646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63647       };
63648     } catch (...) {
63649       {
63650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63651       };
63652     }
63653   }
63654   jresult = (void *)result;
63655   return jresult;
63656 }
63657
63658
63659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63660   void * jresult ;
63661   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63662   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63663
63664   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63665   {
63666     try {
63667       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63668     } catch (std::out_of_range& e) {
63669       {
63670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63671       };
63672     } catch (std::exception& e) {
63673       {
63674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63675       };
63676     } catch (...) {
63677       {
63678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63679       };
63680     }
63681   }
63682   jresult = (void *)result;
63683   return jresult;
63684 }
63685
63686
63687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63688   int jresult ;
63689   int result;
63690
63691   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63692   jresult = (int)result;
63693   return jresult;
63694 }
63695
63696
63697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63698   int jresult ;
63699   int result;
63700
63701   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63702   jresult = (int)result;
63703   return jresult;
63704 }
63705
63706
63707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63708   int jresult ;
63709   int result;
63710
63711   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63712   jresult = (int)result;
63713   return jresult;
63714 }
63715
63716
63717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63718   int jresult ;
63719   int result;
63720
63721   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63722   jresult = (int)result;
63723   return jresult;
63724 }
63725
63726
63727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63728   int jresult ;
63729   int result;
63730
63731   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63732   jresult = (int)result;
63733   return jresult;
63734 }
63735
63736
63737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63738   int jresult ;
63739   int result;
63740
63741   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63742   jresult = (int)result;
63743   return jresult;
63744 }
63745
63746
63747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63748   int jresult ;
63749   int result;
63750
63751   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63752   jresult = (int)result;
63753   return jresult;
63754 }
63755
63756
63757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63758   int jresult ;
63759   int result;
63760
63761   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63762   jresult = (int)result;
63763   return jresult;
63764 }
63765
63766
63767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63768   int jresult ;
63769   int result;
63770
63771   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63772   jresult = (int)result;
63773   return jresult;
63774 }
63775
63776
63777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63778   int jresult ;
63779   int result;
63780
63781   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63782   jresult = (int)result;
63783   return jresult;
63784 }
63785
63786
63787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63788   int jresult ;
63789   int result;
63790
63791   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63792   jresult = (int)result;
63793   return jresult;
63794 }
63795
63796
63797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63798   int jresult ;
63799   int result;
63800
63801   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63802   jresult = (int)result;
63803   return jresult;
63804 }
63805
63806
63807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63808   int jresult ;
63809   int result;
63810
63811   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63812   jresult = (int)result;
63813   return jresult;
63814 }
63815
63816
63817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63818   int jresult ;
63819   int result;
63820
63821   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63822   jresult = (int)result;
63823   return jresult;
63824 }
63825
63826
63827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63828   void * jresult ;
63829   Dali::Toolkit::Scrollable::Property *result = 0 ;
63830
63831   {
63832     try {
63833       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (...) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63845       };
63846     }
63847   }
63848   jresult = (void *)result;
63849   return jresult;
63850 }
63851
63852
63853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63854   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63855
63856   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63857   {
63858     try {
63859       delete arg1;
63860     } catch (std::out_of_range& e) {
63861       {
63862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63863       };
63864     } catch (std::exception& e) {
63865       {
63866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63867       };
63868     } catch (...) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63871       };
63872     }
63873   }
63874 }
63875
63876
63877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63878   void * jresult ;
63879   Dali::Toolkit::Scrollable *result = 0 ;
63880
63881   {
63882     try {
63883       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63884     } catch (std::out_of_range& e) {
63885       {
63886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63887       };
63888     } catch (std::exception& e) {
63889       {
63890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63895       };
63896     }
63897   }
63898   jresult = (void *)result;
63899   return jresult;
63900 }
63901
63902
63903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63904   void * jresult ;
63905   Dali::Toolkit::Scrollable *arg1 = 0 ;
63906   Dali::Toolkit::Scrollable *result = 0 ;
63907
63908   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63909   if (!arg1) {
63910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63911     return 0;
63912   }
63913   {
63914     try {
63915       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63916     } catch (std::out_of_range& e) {
63917       {
63918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63919       };
63920     } catch (std::exception& e) {
63921       {
63922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63923       };
63924     } catch (...) {
63925       {
63926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63927       };
63928     }
63929   }
63930   jresult = (void *)result;
63931   return jresult;
63932 }
63933
63934
63935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63936   void * jresult ;
63937   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63938   Dali::Toolkit::Scrollable *arg2 = 0 ;
63939   Dali::Toolkit::Scrollable *result = 0 ;
63940
63941   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63942   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63943   if (!arg2) {
63944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63945     return 0;
63946   }
63947   {
63948     try {
63949       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63950     } catch (std::out_of_range& e) {
63951       {
63952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63953       };
63954     } catch (std::exception& e) {
63955       {
63956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63957       };
63958     } catch (...) {
63959       {
63960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63961       };
63962     }
63963   }
63964   jresult = (void *)result;
63965   return jresult;
63966 }
63967
63968
63969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63970   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63971
63972   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63973   {
63974     try {
63975       delete arg1;
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63987       };
63988     }
63989   }
63990 }
63991
63992
63993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
63994   void * jresult ;
63995   Dali::BaseHandle arg1 ;
63996   Dali::BaseHandle *argp1 ;
63997   Dali::Toolkit::Scrollable result;
63998
63999   argp1 = (Dali::BaseHandle *)jarg1;
64000   if (!argp1) {
64001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64002     return 0;
64003   }
64004   arg1 = *argp1;
64005   {
64006     try {
64007       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64008     } catch (std::out_of_range& e) {
64009       {
64010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64011       };
64012     } catch (std::exception& e) {
64013       {
64014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64015       };
64016     } catch (...) {
64017       {
64018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64019       };
64020     }
64021   }
64022   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64023   return jresult;
64024 }
64025
64026
64027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64028   unsigned int jresult ;
64029   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64030   bool result;
64031
64032   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64033   {
64034     try {
64035       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64036     } catch (std::out_of_range& e) {
64037       {
64038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64039       };
64040     } catch (std::exception& e) {
64041       {
64042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64043       };
64044     } catch (...) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64047       };
64048     }
64049   }
64050   jresult = result;
64051   return jresult;
64052 }
64053
64054
64055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64056   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64057   bool arg2 ;
64058
64059   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64060   arg2 = jarg2 ? true : false;
64061   {
64062     try {
64063       (arg1)->SetOvershootEnabled(arg2);
64064     } catch (std::out_of_range& e) {
64065       {
64066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64067       };
64068     } catch (std::exception& e) {
64069       {
64070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64071       };
64072     } catch (...) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64075       };
64076     }
64077   }
64078 }
64079
64080
64081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64082   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64083   Dali::Vector4 *arg2 = 0 ;
64084
64085   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64086   arg2 = (Dali::Vector4 *)jarg2;
64087   if (!arg2) {
64088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64089     return ;
64090   }
64091   {
64092     try {
64093       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64094     } catch (std::out_of_range& e) {
64095       {
64096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64097       };
64098     } catch (std::exception& e) {
64099       {
64100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64101       };
64102     } catch (...) {
64103       {
64104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64105       };
64106     }
64107   }
64108 }
64109
64110
64111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64112   void * jresult ;
64113   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64114   Dali::Vector4 result;
64115
64116   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64117   {
64118     try {
64119       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64120     } catch (std::out_of_range& e) {
64121       {
64122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64123       };
64124     } catch (std::exception& e) {
64125       {
64126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (...) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64131       };
64132     }
64133   }
64134   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64135   return jresult;
64136 }
64137
64138
64139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64140   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64141   float arg2 ;
64142
64143   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64144   arg2 = (float)jarg2;
64145   {
64146     try {
64147       (arg1)->SetOvershootAnimationSpeed(arg2);
64148     } catch (std::out_of_range& e) {
64149       {
64150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64151       };
64152     } catch (std::exception& e) {
64153       {
64154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64155       };
64156     } catch (...) {
64157       {
64158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64159       };
64160     }
64161   }
64162 }
64163
64164
64165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64166   float jresult ;
64167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64168   float result;
64169
64170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64171   {
64172     try {
64173       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64174     } catch (std::out_of_range& e) {
64175       {
64176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64177       };
64178     } catch (std::exception& e) {
64179       {
64180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64181       };
64182     } catch (...) {
64183       {
64184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64185       };
64186     }
64187   }
64188   jresult = result;
64189   return jresult;
64190 }
64191
64192
64193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64194   void * jresult ;
64195   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64196   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64197
64198   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64199   {
64200     try {
64201       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64209       };
64210     } catch (...) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64213       };
64214     }
64215   }
64216   jresult = (void *)result;
64217   return jresult;
64218 }
64219
64220
64221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64222   void * jresult ;
64223   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64224   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64225
64226   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64227   {
64228     try {
64229       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64230     } catch (std::out_of_range& e) {
64231       {
64232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64233       };
64234     } catch (std::exception& e) {
64235       {
64236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64237       };
64238     } catch (...) {
64239       {
64240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64241       };
64242     }
64243   }
64244   jresult = (void *)result;
64245   return jresult;
64246 }
64247
64248
64249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64250   void * jresult ;
64251   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64252   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64253
64254   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64255   {
64256     try {
64257       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64258     } catch (std::out_of_range& e) {
64259       {
64260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64261       };
64262     } catch (std::exception& e) {
64263       {
64264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64265       };
64266     } catch (...) {
64267       {
64268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64269       };
64270     }
64271   }
64272   jresult = (void *)result;
64273   return jresult;
64274 }
64275
64276
64277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64278   unsigned int jresult ;
64279   Dali::Toolkit::ControlOrientation::Type arg1 ;
64280   bool result;
64281
64282   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64283   {
64284     try {
64285       result = (bool)Dali::Toolkit::IsVertical(arg1);
64286     } catch (std::out_of_range& e) {
64287       {
64288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64289       };
64290     } catch (std::exception& e) {
64291       {
64292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64293       };
64294     } catch (...) {
64295       {
64296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64297       };
64298     }
64299   }
64300   jresult = result;
64301   return jresult;
64302 }
64303
64304
64305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64306   unsigned int jresult ;
64307   Dali::Toolkit::ControlOrientation::Type arg1 ;
64308   bool result;
64309
64310   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64311   {
64312     try {
64313       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64314     } catch (std::out_of_range& e) {
64315       {
64316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64317       };
64318     } catch (std::exception& e) {
64319       {
64320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64321       };
64322     } catch (...) {
64323       {
64324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64325       };
64326     }
64327   }
64328   jresult = result;
64329   return jresult;
64330 }
64331
64332
64333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64334   void * jresult ;
64335   unsigned int arg1 ;
64336   unsigned int arg2 ;
64337   Dali::Toolkit::ItemRange *result = 0 ;
64338
64339   arg1 = (unsigned int)jarg1;
64340   arg2 = (unsigned int)jarg2;
64341   {
64342     try {
64343       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64344     } catch (std::out_of_range& e) {
64345       {
64346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64347       };
64348     } catch (std::exception& e) {
64349       {
64350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64351       };
64352     } catch (...) {
64353       {
64354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64355       };
64356     }
64357   }
64358   jresult = (void *)result;
64359   return jresult;
64360 }
64361
64362
64363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64364   void * jresult ;
64365   Dali::Toolkit::ItemRange *arg1 = 0 ;
64366   Dali::Toolkit::ItemRange *result = 0 ;
64367
64368   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64369   if (!arg1) {
64370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64371     return 0;
64372   }
64373   {
64374     try {
64375       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64376     } catch (std::out_of_range& e) {
64377       {
64378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64379       };
64380     } catch (std::exception& e) {
64381       {
64382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64383       };
64384     } catch (...) {
64385       {
64386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64387       };
64388     }
64389   }
64390   jresult = (void *)result;
64391   return jresult;
64392 }
64393
64394
64395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64396   void * jresult ;
64397   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64398   Dali::Toolkit::ItemRange *arg2 = 0 ;
64399   Dali::Toolkit::ItemRange *result = 0 ;
64400
64401   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64402   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64403   if (!arg2) {
64404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64405     return 0;
64406   }
64407   {
64408     try {
64409       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64410     } catch (std::out_of_range& e) {
64411       {
64412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64413       };
64414     } catch (std::exception& e) {
64415       {
64416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64417       };
64418     } catch (...) {
64419       {
64420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64421       };
64422     }
64423   }
64424   jresult = (void *)result;
64425   return jresult;
64426 }
64427
64428
64429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64430   unsigned int jresult ;
64431   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64432   unsigned int arg2 ;
64433   bool result;
64434
64435   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64436   arg2 = (unsigned int)jarg2;
64437   {
64438     try {
64439       result = (bool)(arg1)->Within(arg2);
64440     } catch (std::out_of_range& e) {
64441       {
64442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64443       };
64444     } catch (std::exception& e) {
64445       {
64446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64447       };
64448     } catch (...) {
64449       {
64450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64451       };
64452     }
64453   }
64454   jresult = result;
64455   return jresult;
64456 }
64457
64458
64459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64460   void * jresult ;
64461   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64462   Dali::Toolkit::ItemRange *arg2 = 0 ;
64463   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64464
64465   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64466   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64467   if (!arg2) {
64468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64469     return 0;
64470   }
64471   {
64472     try {
64473       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64474     } catch (std::out_of_range& e) {
64475       {
64476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64477       };
64478     } catch (std::exception& e) {
64479       {
64480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64481       };
64482     } catch (...) {
64483       {
64484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64485       };
64486     }
64487   }
64488   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64489   return jresult;
64490 }
64491
64492
64493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64494   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64495   unsigned int arg2 ;
64496
64497   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64498   arg2 = (unsigned int)jarg2;
64499   if (arg1) (arg1)->begin = arg2;
64500 }
64501
64502
64503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64504   unsigned int jresult ;
64505   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64506   unsigned int result;
64507
64508   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64509   result = (unsigned int) ((arg1)->begin);
64510   jresult = result;
64511   return jresult;
64512 }
64513
64514
64515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64516   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64517   unsigned int arg2 ;
64518
64519   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64520   arg2 = (unsigned int)jarg2;
64521   if (arg1) (arg1)->end = arg2;
64522 }
64523
64524
64525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64526   unsigned int jresult ;
64527   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64528   unsigned int result;
64529
64530   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64531   result = (unsigned int) ((arg1)->end);
64532   jresult = result;
64533   return jresult;
64534 }
64535
64536
64537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64538   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64539
64540   arg1 = (Dali::Toolkit::ItemRange *)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_delete_ItemLayout(void * jarg1) {
64562   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64563
64564   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64565   {
64566     try {
64567       delete arg1;
64568     } catch (std::out_of_range& e) {
64569       {
64570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64571       };
64572     } catch (std::exception& e) {
64573       {
64574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64575       };
64576     } catch (...) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64579       };
64580     }
64581   }
64582 }
64583
64584
64585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64586   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64587   Dali::Toolkit::ControlOrientation::Type arg2 ;
64588
64589   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64590   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64591   {
64592     try {
64593       (arg1)->SetOrientation(arg2);
64594     } catch (std::out_of_range& e) {
64595       {
64596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64597       };
64598     } catch (std::exception& e) {
64599       {
64600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64601       };
64602     } catch (...) {
64603       {
64604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64605       };
64606     }
64607   }
64608 }
64609
64610
64611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64612   int jresult ;
64613   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64614   Dali::Toolkit::ControlOrientation::Type result;
64615
64616   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64617   {
64618     try {
64619       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64620     } catch (std::out_of_range& e) {
64621       {
64622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (std::exception& e) {
64625       {
64626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64631       };
64632     }
64633   }
64634   jresult = (int)result;
64635   return jresult;
64636 }
64637
64638
64639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64640   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64641   Dali::Property::Map *arg2 = 0 ;
64642
64643   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64644   arg2 = (Dali::Property::Map *)jarg2;
64645   if (!arg2) {
64646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64647     return ;
64648   }
64649   {
64650     try {
64651       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64652     } catch (std::out_of_range& e) {
64653       {
64654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64655       };
64656     } catch (std::exception& e) {
64657       {
64658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64659       };
64660     } catch (...) {
64661       {
64662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64663       };
64664     }
64665   }
64666 }
64667
64668
64669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64670   void * jresult ;
64671   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64672   Dali::Property::Map result;
64673
64674   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64675   {
64676     try {
64677       result = (arg1)->GetLayoutProperties();
64678     } catch (std::out_of_range& e) {
64679       {
64680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64681       };
64682     } catch (std::exception& e) {
64683       {
64684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64685       };
64686     } catch (...) {
64687       {
64688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64689       };
64690     }
64691   }
64692   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64693   return jresult;
64694 }
64695
64696
64697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64698   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64699   unsigned int arg2 ;
64700   Dali::Vector3 *arg3 = 0 ;
64701   Dali::Vector3 *arg4 = 0 ;
64702
64703   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64704   arg2 = (unsigned int)jarg2;
64705   arg3 = (Dali::Vector3 *)jarg3;
64706   if (!arg3) {
64707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64708     return ;
64709   }
64710   arg4 = (Dali::Vector3 *)jarg4;
64711   if (!arg4) {
64712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64713     return ;
64714   }
64715   {
64716     try {
64717       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64718     } catch (std::out_of_range& e) {
64719       {
64720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64721       };
64722     } catch (std::exception& e) {
64723       {
64724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64725       };
64726     } catch (...) {
64727       {
64728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64729       };
64730     }
64731   }
64732 }
64733
64734
64735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64736   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64737   Dali::Vector3 *arg2 = 0 ;
64738
64739   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64740   arg2 = (Dali::Vector3 *)jarg2;
64741   if (!arg2) {
64742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64743     return ;
64744   }
64745   {
64746     try {
64747       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64748     } catch (std::out_of_range& e) {
64749       {
64750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64751       };
64752     } catch (std::exception& e) {
64753       {
64754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64755       };
64756     } catch (...) {
64757       {
64758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64759       };
64760     }
64761   }
64762 }
64763
64764
64765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64766   float jresult ;
64767   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64768   unsigned int arg2 ;
64769   Dali::Vector3 arg3 ;
64770   Dali::Vector3 *argp3 ;
64771   float result;
64772
64773   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64774   arg2 = (unsigned int)jarg2;
64775   argp3 = (Dali::Vector3 *)jarg3;
64776   if (!argp3) {
64777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64778     return 0;
64779   }
64780   arg3 = *argp3;
64781   {
64782     try {
64783       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64784     } catch (std::out_of_range& e) {
64785       {
64786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64787       };
64788     } catch (std::exception& e) {
64789       {
64790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64791       };
64792     } catch (...) {
64793       {
64794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64795       };
64796     }
64797   }
64798   jresult = result;
64799   return jresult;
64800 }
64801
64802
64803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64804   float jresult ;
64805   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64806   float arg2 ;
64807   float result;
64808
64809   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64810   arg2 = (float)jarg2;
64811   {
64812     try {
64813       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64814     } catch (std::out_of_range& e) {
64815       {
64816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64817       };
64818     } catch (std::exception& e) {
64819       {
64820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64821       };
64822     } catch (...) {
64823       {
64824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64825       };
64826     }
64827   }
64828   jresult = result;
64829   return jresult;
64830 }
64831
64832
64833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64834   float jresult ;
64835   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64836   unsigned int arg2 ;
64837   float result;
64838
64839   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64840   arg2 = (unsigned int)jarg2;
64841   {
64842     try {
64843       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64844     } catch (std::out_of_range& e) {
64845       {
64846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64847       };
64848     } catch (std::exception& e) {
64849       {
64850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64851       };
64852     } catch (...) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64855       };
64856     }
64857   }
64858   jresult = result;
64859   return jresult;
64860 }
64861
64862
64863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64864   void * jresult ;
64865   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64866   float arg2 ;
64867   Dali::Vector3 arg3 ;
64868   Dali::Vector3 *argp3 ;
64869   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64870
64871   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64872   arg2 = (float)jarg2;
64873   argp3 = (Dali::Vector3 *)jarg3;
64874   if (!argp3) {
64875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64876     return 0;
64877   }
64878   arg3 = *argp3;
64879   {
64880     try {
64881       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64882     } catch (std::out_of_range& e) {
64883       {
64884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64885       };
64886     } catch (std::exception& e) {
64887       {
64888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64889       };
64890     } catch (...) {
64891       {
64892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64893       };
64894     }
64895   }
64896   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64897   return jresult;
64898 }
64899
64900
64901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64902   float jresult ;
64903   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64904   int arg2 ;
64905   float arg3 ;
64906   Dali::Vector3 *arg4 = 0 ;
64907   float result;
64908
64909   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64910   arg2 = (int)jarg2;
64911   arg3 = (float)jarg3;
64912   arg4 = (Dali::Vector3 *)jarg4;
64913   if (!arg4) {
64914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64915     return 0;
64916   }
64917   {
64918     try {
64919       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64920     } catch (std::out_of_range& e) {
64921       {
64922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64923       };
64924     } catch (std::exception& e) {
64925       {
64926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64927       };
64928     } catch (...) {
64929       {
64930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64931       };
64932     }
64933   }
64934   jresult = result;
64935   return jresult;
64936 }
64937
64938
64939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64940   unsigned int jresult ;
64941   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64942   Dali::Vector3 arg2 ;
64943   Dali::Vector3 *argp2 ;
64944   unsigned int result;
64945
64946   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64947   argp2 = (Dali::Vector3 *)jarg2;
64948   if (!argp2) {
64949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64950     return 0;
64951   }
64952   arg2 = *argp2;
64953   {
64954     try {
64955       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64956     } catch (std::out_of_range& e) {
64957       {
64958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64959       };
64960     } catch (std::exception& e) {
64961       {
64962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (...) {
64965       {
64966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64967       };
64968     }
64969   }
64970   jresult = result;
64971   return jresult;
64972 }
64973
64974
64975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64976   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64977   unsigned int arg2 ;
64978   Dali::Vector3 *arg3 = 0 ;
64979   Dali::Vector3 *arg4 = 0 ;
64980
64981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64982   arg2 = (unsigned int)jarg2;
64983   arg3 = (Dali::Vector3 *)jarg3;
64984   if (!arg3) {
64985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64986     return ;
64987   }
64988   arg4 = (Dali::Vector3 *)jarg4;
64989   if (!arg4) {
64990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64991     return ;
64992   }
64993   {
64994     try {
64995       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64996     } catch (std::out_of_range& e) {
64997       {
64998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64999       };
65000     } catch (std::exception& e) {
65001       {
65002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65003       };
65004     } catch (...) {
65005       {
65006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65007       };
65008     }
65009   }
65010 }
65011
65012
65013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65014   void * jresult ;
65015   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65016   Dali::Degree result;
65017
65018   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65019   {
65020     try {
65021       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
65022     } catch (std::out_of_range& e) {
65023       {
65024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65025       };
65026     } catch (std::exception& e) {
65027       {
65028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65029       };
65030     } catch (...) {
65031       {
65032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65033       };
65034     }
65035   }
65036   jresult = new Dali::Degree((const Dali::Degree &)result);
65037   return jresult;
65038 }
65039
65040
65041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65042   float jresult ;
65043   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65044   float result;
65045
65046   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65047   {
65048     try {
65049       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65050     } catch (std::out_of_range& e) {
65051       {
65052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65053       };
65054     } catch (std::exception& e) {
65055       {
65056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65057       };
65058     } catch (...) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65061       };
65062     }
65063   }
65064   jresult = result;
65065   return jresult;
65066 }
65067
65068
65069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65070   float jresult ;
65071   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65072   float result;
65073
65074   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65075   {
65076     try {
65077       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65078     } catch (std::out_of_range& e) {
65079       {
65080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65081       };
65082     } catch (std::exception& e) {
65083       {
65084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (...) {
65087       {
65088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65089       };
65090     }
65091   }
65092   jresult = result;
65093   return jresult;
65094 }
65095
65096
65097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65098   float jresult ;
65099   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65100   float result;
65101
65102   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65103   {
65104     try {
65105       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65106     } catch (std::out_of_range& e) {
65107       {
65108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (std::exception& e) {
65111       {
65112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120   jresult = result;
65121   return jresult;
65122 }
65123
65124
65125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65126   int jresult ;
65127   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65128   int arg2 ;
65129   int arg3 ;
65130   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65131   bool arg5 ;
65132   int result;
65133
65134   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65135   arg2 = (int)jarg2;
65136   arg3 = (int)jarg3;
65137   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65138   arg5 = jarg5 ? true : false;
65139   {
65140     try {
65141       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65142     } catch (std::out_of_range& e) {
65143       {
65144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (std::exception& e) {
65147       {
65148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65153       };
65154     }
65155   }
65156   jresult = result;
65157   return jresult;
65158 }
65159
65160
65161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65162   float jresult ;
65163   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65164   float result;
65165
65166   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65167   {
65168     try {
65169       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65170     } catch (std::out_of_range& e) {
65171       {
65172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65173       };
65174     } catch (std::exception& e) {
65175       {
65176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65177       };
65178     } catch (...) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65181       };
65182     }
65183   }
65184   jresult = result;
65185   return jresult;
65186 }
65187
65188
65189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65190   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65191   Dali::Actor *arg2 = 0 ;
65192   int arg3 ;
65193   Dali::Vector3 *arg4 = 0 ;
65194   Dali::Actor *arg5 = 0 ;
65195
65196   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65197   arg2 = (Dali::Actor *)jarg2;
65198   if (!arg2) {
65199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65200     return ;
65201   }
65202   arg3 = (int)jarg3;
65203   arg4 = (Dali::Vector3 *)jarg4;
65204   if (!arg4) {
65205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65206     return ;
65207   }
65208   arg5 = (Dali::Actor *)jarg5;
65209   if (!arg5) {
65210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65211     return ;
65212   }
65213   {
65214     try {
65215       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65216     } catch (std::out_of_range& e) {
65217       {
65218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65219       };
65220     } catch (std::exception& e) {
65221       {
65222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65223       };
65224     } catch (...) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65227       };
65228     }
65229   }
65230 }
65231
65232
65233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65234   void * jresult ;
65235   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65236   int arg2 ;
65237   float arg3 ;
65238   Dali::Vector3 *arg4 = 0 ;
65239   Dali::Vector3 result;
65240
65241   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65242   arg2 = (int)jarg2;
65243   arg3 = (float)jarg3;
65244   arg4 = (Dali::Vector3 *)jarg4;
65245   if (!arg4) {
65246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65247     return 0;
65248   }
65249   {
65250     try {
65251       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65252     } catch (std::out_of_range& e) {
65253       {
65254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65255       };
65256     } catch (std::exception& e) {
65257       {
65258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (...) {
65261       {
65262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65263       };
65264     }
65265   }
65266   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65267   return jresult;
65268 }
65269
65270
65271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65272   void * jresult ;
65273   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65274   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65275
65276   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65277   {
65278     try {
65279       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65280     } catch (std::out_of_range& e) {
65281       {
65282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65283       };
65284     } catch (std::exception& e) {
65285       {
65286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65287       };
65288     } catch (...) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65291       };
65292     }
65293   }
65294   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65295   return jresult;
65296 }
65297
65298
65299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65300   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65301
65302   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65303   {
65304     try {
65305       delete arg1;
65306     } catch (std::out_of_range& e) {
65307       {
65308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65309       };
65310     } catch (std::exception& e) {
65311       {
65312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65313       };
65314     } catch (...) {
65315       {
65316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65317       };
65318     }
65319   }
65320 }
65321
65322
65323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65324   unsigned int jresult ;
65325   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65326   unsigned int result;
65327
65328   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65329   {
65330     try {
65331       result = (unsigned int)(arg1)->GetNumberOfItems();
65332     } catch (std::out_of_range& e) {
65333       {
65334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65335       };
65336     } catch (std::exception& e) {
65337       {
65338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65339       };
65340     } catch (...) {
65341       {
65342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65343       };
65344     }
65345   }
65346   jresult = result;
65347   return jresult;
65348 }
65349
65350
65351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65352   void * jresult ;
65353   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65354   unsigned int arg2 ;
65355   Dali::Actor result;
65356
65357   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65358   arg2 = (unsigned int)jarg2;
65359   {
65360     try {
65361       result = (arg1)->NewItem(arg2);
65362     } catch (std::out_of_range& e) {
65363       {
65364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65365       };
65366     } catch (std::exception& e) {
65367       {
65368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65369       };
65370     } catch (...) {
65371       {
65372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65373       };
65374     }
65375   }
65376   jresult = new Dali::Actor((const Dali::Actor &)result);
65377   return jresult;
65378 }
65379
65380
65381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65382   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65383   unsigned int arg2 ;
65384   Dali::Actor arg3 ;
65385   Dali::Actor *argp3 ;
65386
65387   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65388   arg2 = (unsigned int)jarg2;
65389   argp3 = (Dali::Actor *)jarg3;
65390   if (!argp3) {
65391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65392     return ;
65393   }
65394   arg3 = *argp3;
65395   {
65396     try {
65397       (arg1)->ItemReleased(arg2,arg3);
65398     } catch (std::out_of_range& e) {
65399       {
65400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65401       };
65402     } catch (std::exception& e) {
65403       {
65404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65405       };
65406     } catch (...) {
65407       {
65408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65409       };
65410     }
65411   }
65412 }
65413
65414
65415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65416   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65417   unsigned int arg2 ;
65418   Dali::Actor arg3 ;
65419   Dali::Actor *argp3 ;
65420
65421   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65422   arg2 = (unsigned int)jarg2;
65423   argp3 = (Dali::Actor *)jarg3;
65424   if (!argp3) {
65425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65426     return ;
65427   }
65428   arg3 = *argp3;
65429   {
65430     try {
65431       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65432     } catch (std::out_of_range& e) {
65433       {
65434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65435       };
65436     } catch (std::exception& e) {
65437       {
65438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65439       };
65440     } catch (...) {
65441       {
65442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65443       };
65444     }
65445   }
65446 }
65447
65448
65449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65450   void * jresult ;
65451   Dali::Toolkit::ItemFactory *result = 0 ;
65452
65453   {
65454     try {
65455       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65456     } catch (std::out_of_range& e) {
65457       {
65458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65459       };
65460     } catch (std::exception& e) {
65461       {
65462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65463       };
65464     } catch (...) {
65465       {
65466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65467       };
65468     }
65469   }
65470   jresult = (void *)result;
65471   return jresult;
65472 }
65473
65474
65475 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) {
65476   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65477   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65478   if (director) {
65479     director->swig_connect_director(callback0, callback1, callback2);
65480   }
65481 }
65482
65483
65484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65485   int jresult ;
65486   int result;
65487
65488   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65489   jresult = (int)result;
65490   return jresult;
65491 }
65492
65493
65494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65495   int jresult ;
65496   int result;
65497
65498   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65499   jresult = (int)result;
65500   return jresult;
65501 }
65502
65503
65504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65505   int jresult ;
65506   int result;
65507
65508   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65509   jresult = (int)result;
65510   return jresult;
65511 }
65512
65513
65514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65515   int jresult ;
65516   int result;
65517
65518   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65519   jresult = (int)result;
65520   return jresult;
65521 }
65522
65523
65524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65525   int jresult ;
65526   int result;
65527
65528   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65529   jresult = (int)result;
65530   return jresult;
65531 }
65532
65533
65534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65535   int jresult ;
65536   int result;
65537
65538   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65539   jresult = (int)result;
65540   return jresult;
65541 }
65542
65543
65544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65545   int jresult ;
65546   int result;
65547
65548   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65549   jresult = (int)result;
65550   return jresult;
65551 }
65552
65553
65554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65555   int jresult ;
65556   int result;
65557
65558   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65559   jresult = (int)result;
65560   return jresult;
65561 }
65562
65563
65564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65565   int jresult ;
65566   int result;
65567
65568   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65569   jresult = (int)result;
65570   return jresult;
65571 }
65572
65573
65574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65575   int jresult ;
65576   int result;
65577
65578   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65579   jresult = (int)result;
65580   return jresult;
65581 }
65582
65583
65584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65585   int jresult ;
65586   int result;
65587
65588   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65589   jresult = (int)result;
65590   return jresult;
65591 }
65592
65593
65594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65595   void * jresult ;
65596   Dali::Toolkit::ItemView::Property *result = 0 ;
65597
65598   {
65599     try {
65600       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65608       };
65609     } catch (...) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65612       };
65613     }
65614   }
65615   jresult = (void *)result;
65616   return jresult;
65617 }
65618
65619
65620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65621   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65622
65623   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65624   {
65625     try {
65626       delete arg1;
65627     } catch (std::out_of_range& e) {
65628       {
65629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65630       };
65631     } catch (std::exception& e) {
65632       {
65633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65638       };
65639     }
65640   }
65641 }
65642
65643
65644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65645   void * jresult ;
65646   Dali::Toolkit::ItemView *result = 0 ;
65647
65648   {
65649     try {
65650       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65651     } catch (std::out_of_range& e) {
65652       {
65653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65654       };
65655     } catch (std::exception& e) {
65656       {
65657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65658       };
65659     } catch (...) {
65660       {
65661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65662       };
65663     }
65664   }
65665   jresult = (void *)result;
65666   return jresult;
65667 }
65668
65669
65670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65671   void * jresult ;
65672   Dali::Toolkit::ItemView *arg1 = 0 ;
65673   Dali::Toolkit::ItemView *result = 0 ;
65674
65675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65676   if (!arg1) {
65677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65678     return 0;
65679   }
65680   {
65681     try {
65682       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65683     } catch (std::out_of_range& e) {
65684       {
65685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65686       };
65687     } catch (std::exception& e) {
65688       {
65689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (...) {
65692       {
65693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65694       };
65695     }
65696   }
65697   jresult = (void *)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65703   void * jresult ;
65704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65705   Dali::Toolkit::ItemView *arg2 = 0 ;
65706   Dali::Toolkit::ItemView *result = 0 ;
65707
65708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65709   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65710   if (!arg2) {
65711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65712     return 0;
65713   }
65714   {
65715     try {
65716       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65717     } catch (std::out_of_range& e) {
65718       {
65719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65720       };
65721     } catch (std::exception& e) {
65722       {
65723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65724       };
65725     } catch (...) {
65726       {
65727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65728       };
65729     }
65730   }
65731   jresult = (void *)result;
65732   return jresult;
65733 }
65734
65735
65736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65738
65739   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65740   {
65741     try {
65742       delete arg1;
65743     } catch (std::out_of_range& e) {
65744       {
65745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65746       };
65747     } catch (std::exception& e) {
65748       {
65749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65750       };
65751     } catch (...) {
65752       {
65753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65754       };
65755     }
65756   }
65757 }
65758
65759
65760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65761   void * jresult ;
65762   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65763   Dali::Toolkit::ItemView result;
65764
65765   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65766   if (!arg1) {
65767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65768     return 0;
65769   }
65770   {
65771     try {
65772       result = Dali::Toolkit::ItemView::New(*arg1);
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (...) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65784       };
65785     }
65786   }
65787   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65793   void * jresult ;
65794   Dali::BaseHandle arg1 ;
65795   Dali::BaseHandle *argp1 ;
65796   Dali::Toolkit::ItemView result;
65797
65798   argp1 = (Dali::BaseHandle *)jarg1;
65799   if (!argp1) {
65800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65801     return 0;
65802   }
65803   arg1 = *argp1;
65804   {
65805     try {
65806       result = Dali::Toolkit::ItemView::DownCast(arg1);
65807     } catch (std::out_of_range& e) {
65808       {
65809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65810       };
65811     } catch (std::exception& e) {
65812       {
65813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (...) {
65816       {
65817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65818       };
65819     }
65820   }
65821   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65822   return jresult;
65823 }
65824
65825
65826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65827   unsigned int jresult ;
65828   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65829   unsigned int result;
65830
65831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65832   {
65833     try {
65834       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65835     } catch (std::out_of_range& e) {
65836       {
65837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65838       };
65839     } catch (std::exception& e) {
65840       {
65841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65842       };
65843     } catch (...) {
65844       {
65845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65846       };
65847     }
65848   }
65849   jresult = result;
65850   return jresult;
65851 }
65852
65853
65854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65855   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65856   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65857
65858   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65859   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65860   if (!arg2) {
65861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65862     return ;
65863   }
65864   {
65865     try {
65866       (arg1)->AddLayout(*arg2);
65867     } catch (std::out_of_range& e) {
65868       {
65869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65870       };
65871     } catch (std::exception& e) {
65872       {
65873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65874       };
65875     } catch (...) {
65876       {
65877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65878       };
65879     }
65880   }
65881 }
65882
65883
65884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65885   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65886   unsigned int arg2 ;
65887
65888   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65889   arg2 = (unsigned int)jarg2;
65890   {
65891     try {
65892       (arg1)->RemoveLayout(arg2);
65893     } catch (std::out_of_range& e) {
65894       {
65895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65896       };
65897     } catch (std::exception& e) {
65898       {
65899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65900       };
65901     } catch (...) {
65902       {
65903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65904       };
65905     }
65906   }
65907 }
65908
65909
65910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65911   void * jresult ;
65912   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65913   unsigned int arg2 ;
65914   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65915
65916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65917   arg2 = (unsigned int)jarg2;
65918   {
65919     try {
65920       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65921     } catch (std::out_of_range& e) {
65922       {
65923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65924       };
65925     } catch (std::exception& e) {
65926       {
65927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65928       };
65929     } catch (...) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65932       };
65933     }
65934   }
65935   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65936   return jresult;
65937 }
65938
65939
65940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65941   void * jresult ;
65942   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65943   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65944
65945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65946   {
65947     try {
65948       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65949     } catch (std::out_of_range& e) {
65950       {
65951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65952       };
65953     } catch (std::exception& e) {
65954       {
65955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65956       };
65957     } catch (...) {
65958       {
65959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65960       };
65961     }
65962   }
65963   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65964   return jresult;
65965 }
65966
65967
65968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65969   float jresult ;
65970   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65971   Dali::Toolkit::ItemId arg2 ;
65972   float result;
65973
65974   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65975   arg2 = (Dali::Toolkit::ItemId)jarg2;
65976   {
65977     try {
65978       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65979     } catch (std::out_of_range& e) {
65980       {
65981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65982       };
65983     } catch (std::exception& e) {
65984       {
65985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65986       };
65987     } catch (...) {
65988       {
65989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65990       };
65991     }
65992   }
65993   jresult = result;
65994   return jresult;
65995 }
65996
65997
65998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
65999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66000   unsigned int arg2 ;
66001   Dali::Vector3 arg3 ;
66002   float arg4 ;
66003   Dali::Vector3 *argp3 ;
66004
66005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66006   arg2 = (unsigned int)jarg2;
66007   argp3 = (Dali::Vector3 *)jarg3;
66008   if (!argp3) {
66009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66010     return ;
66011   }
66012   arg3 = *argp3;
66013   arg4 = (float)jarg4;
66014   {
66015     try {
66016       (arg1)->ActivateLayout(arg2,arg3,arg4);
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_DeactivateCurrentLayout(void * jarg1) {
66035   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66036
66037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66038   {
66039     try {
66040       (arg1)->DeactivateCurrentLayout();
66041     } catch (std::out_of_range& e) {
66042       {
66043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66044       };
66045     } catch (std::exception& e) {
66046       {
66047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66048       };
66049     } catch (...) {
66050       {
66051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66052       };
66053     }
66054   }
66055 }
66056
66057
66058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66060   float arg2 ;
66061
66062   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66063   arg2 = (float)jarg2;
66064   {
66065     try {
66066       (arg1)->SetMinimumSwipeSpeed(arg2);
66067     } catch (std::out_of_range& e) {
66068       {
66069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66070       };
66071     } catch (std::exception& e) {
66072       {
66073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66074       };
66075     } catch (...) {
66076       {
66077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66078       };
66079     }
66080   }
66081 }
66082
66083
66084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66085   float jresult ;
66086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66087   float result;
66088
66089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66090   {
66091     try {
66092       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66093     } catch (std::out_of_range& e) {
66094       {
66095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66096       };
66097     } catch (std::exception& e) {
66098       {
66099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66100       };
66101     } catch (...) {
66102       {
66103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66104       };
66105     }
66106   }
66107   jresult = result;
66108   return jresult;
66109 }
66110
66111
66112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66114   float arg2 ;
66115
66116   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66117   arg2 = (float)jarg2;
66118   {
66119     try {
66120       (arg1)->SetMinimumSwipeDistance(arg2);
66121     } catch (std::out_of_range& e) {
66122       {
66123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66124       };
66125     } catch (std::exception& e) {
66126       {
66127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66128       };
66129     } catch (...) {
66130       {
66131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66132       };
66133     }
66134   }
66135 }
66136
66137
66138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66139   float jresult ;
66140   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66141   float result;
66142
66143   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66144   {
66145     try {
66146       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66147     } catch (std::out_of_range& e) {
66148       {
66149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66150       };
66151     } catch (std::exception& e) {
66152       {
66153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66154       };
66155     } catch (...) {
66156       {
66157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66158       };
66159     }
66160   }
66161   jresult = result;
66162   return jresult;
66163 }
66164
66165
66166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66168   float arg2 ;
66169
66170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66171   arg2 = (float)jarg2;
66172   {
66173     try {
66174       (arg1)->SetWheelScrollDistanceStep(arg2);
66175     } catch (std::out_of_range& e) {
66176       {
66177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66178       };
66179     } catch (std::exception& e) {
66180       {
66181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66182       };
66183     } catch (...) {
66184       {
66185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66186       };
66187     }
66188   }
66189 }
66190
66191
66192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66193   float jresult ;
66194   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66195   float result;
66196
66197   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66198   {
66199     try {
66200       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66201     } catch (std::out_of_range& e) {
66202       {
66203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66204       };
66205     } catch (std::exception& e) {
66206       {
66207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66208       };
66209     } catch (...) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66212       };
66213     }
66214   }
66215   jresult = result;
66216   return jresult;
66217 }
66218
66219
66220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66221   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66222   bool arg2 ;
66223
66224   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66225   arg2 = jarg2 ? true : false;
66226   {
66227     try {
66228       (arg1)->SetAnchoring(arg2);
66229     } catch (std::out_of_range& e) {
66230       {
66231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66232       };
66233     } catch (std::exception& e) {
66234       {
66235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66236       };
66237     } catch (...) {
66238       {
66239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66240       };
66241     }
66242   }
66243 }
66244
66245
66246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66247   unsigned int jresult ;
66248   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66249   bool result;
66250
66251   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66252   {
66253     try {
66254       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66255     } catch (std::out_of_range& e) {
66256       {
66257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66258       };
66259     } catch (std::exception& e) {
66260       {
66261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (...) {
66264       {
66265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66266       };
66267     }
66268   }
66269   jresult = result;
66270   return jresult;
66271 }
66272
66273
66274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66275   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66276   float arg2 ;
66277
66278   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66279   arg2 = (float)jarg2;
66280   {
66281     try {
66282       (arg1)->SetAnchoringDuration(arg2);
66283     } catch (std::out_of_range& e) {
66284       {
66285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66286       };
66287     } catch (std::exception& e) {
66288       {
66289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66294       };
66295     }
66296   }
66297 }
66298
66299
66300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66301   float jresult ;
66302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66303   float result;
66304
66305   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66306   {
66307     try {
66308       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66309     } catch (std::out_of_range& e) {
66310       {
66311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66312       };
66313     } catch (std::exception& e) {
66314       {
66315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66316       };
66317     } catch (...) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66320       };
66321     }
66322   }
66323   jresult = result;
66324   return jresult;
66325 }
66326
66327
66328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66329   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66330   Dali::Toolkit::ItemId arg2 ;
66331   float arg3 ;
66332
66333   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66334   arg2 = (Dali::Toolkit::ItemId)jarg2;
66335   arg3 = (float)jarg3;
66336   {
66337     try {
66338       (arg1)->ScrollToItem(arg2,arg3);
66339     } catch (std::out_of_range& e) {
66340       {
66341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66342       };
66343     } catch (std::exception& e) {
66344       {
66345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66346       };
66347     } catch (...) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66350       };
66351     }
66352   }
66353 }
66354
66355
66356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66357   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66358   float arg2 ;
66359
66360   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66361   arg2 = (float)jarg2;
66362   {
66363     try {
66364       (arg1)->SetRefreshInterval(arg2);
66365     } catch (std::out_of_range& e) {
66366       {
66367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66368       };
66369     } catch (std::exception& e) {
66370       {
66371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66372       };
66373     } catch (...) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66376       };
66377     }
66378   }
66379 }
66380
66381
66382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66383   float jresult ;
66384   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66385   float result;
66386
66387   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66388   {
66389     try {
66390       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66391     } catch (std::out_of_range& e) {
66392       {
66393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66394       };
66395     } catch (std::exception& e) {
66396       {
66397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66398       };
66399     } catch (...) {
66400       {
66401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66402       };
66403     }
66404   }
66405   jresult = result;
66406   return jresult;
66407 }
66408
66409
66410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66412
66413   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66414   {
66415     try {
66416       (arg1)->Refresh();
66417     } catch (std::out_of_range& e) {
66418       {
66419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66420       };
66421     } catch (std::exception& e) {
66422       {
66423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66424       };
66425     } catch (...) {
66426       {
66427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66428       };
66429     }
66430   }
66431 }
66432
66433
66434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66435   void * jresult ;
66436   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66437   Dali::Toolkit::ItemId arg2 ;
66438   Dali::Actor result;
66439
66440   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66441   arg2 = (Dali::Toolkit::ItemId)jarg2;
66442   {
66443     try {
66444       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66445     } catch (std::out_of_range& e) {
66446       {
66447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66448       };
66449     } catch (std::exception& e) {
66450       {
66451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66452       };
66453     } catch (...) {
66454       {
66455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66456       };
66457     }
66458   }
66459   jresult = new Dali::Actor((const Dali::Actor &)result);
66460   return jresult;
66461 }
66462
66463
66464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66465   unsigned int jresult ;
66466   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66467   Dali::Actor arg2 ;
66468   Dali::Actor *argp2 ;
66469   Dali::Toolkit::ItemId result;
66470
66471   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66472   argp2 = (Dali::Actor *)jarg2;
66473   if (!argp2) {
66474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66475     return 0;
66476   }
66477   arg2 = *argp2;
66478   {
66479     try {
66480       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66481     } catch (std::out_of_range& e) {
66482       {
66483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (std::exception& e) {
66486       {
66487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66492       };
66493     }
66494   }
66495   jresult = result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66501   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66502   Dali::Toolkit::Item arg2 ;
66503   float arg3 ;
66504   Dali::Toolkit::Item *argp2 ;
66505
66506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66507   argp2 = (Dali::Toolkit::Item *)jarg2;
66508   if (!argp2) {
66509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66510     return ;
66511   }
66512   arg2 = *argp2;
66513   arg3 = (float)jarg3;
66514   {
66515     try {
66516       (arg1)->InsertItem(arg2,arg3);
66517     } catch (std::out_of_range& e) {
66518       {
66519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66520       };
66521     } catch (std::exception& e) {
66522       {
66523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66524       };
66525     } catch (...) {
66526       {
66527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66528       };
66529     }
66530   }
66531 }
66532
66533
66534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66535   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66536   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66537   float arg3 ;
66538
66539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66540   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66541   if (!arg2) {
66542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66543     return ;
66544   }
66545   arg3 = (float)jarg3;
66546   {
66547     try {
66548       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66549     } catch (std::out_of_range& e) {
66550       {
66551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66552       };
66553     } catch (std::exception& e) {
66554       {
66555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66556       };
66557     } catch (...) {
66558       {
66559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66560       };
66561     }
66562   }
66563 }
66564
66565
66566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66568   Dali::Toolkit::ItemId arg2 ;
66569   float arg3 ;
66570
66571   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66572   arg2 = (Dali::Toolkit::ItemId)jarg2;
66573   arg3 = (float)jarg3;
66574   {
66575     try {
66576       (arg1)->RemoveItem(arg2,arg3);
66577     } catch (std::out_of_range& e) {
66578       {
66579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66580       };
66581     } catch (std::exception& e) {
66582       {
66583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66584       };
66585     } catch (...) {
66586       {
66587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66588       };
66589     }
66590   }
66591 }
66592
66593
66594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66595   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66596   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66597   float arg3 ;
66598
66599   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66600   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66601   if (!arg2) {
66602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66603     return ;
66604   }
66605   arg3 = (float)jarg3;
66606   {
66607     try {
66608       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66609     } catch (std::out_of_range& e) {
66610       {
66611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66612       };
66613     } catch (std::exception& e) {
66614       {
66615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66616       };
66617     } catch (...) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66620       };
66621     }
66622   }
66623 }
66624
66625
66626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66627   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66628   Dali::Toolkit::Item arg2 ;
66629   float arg3 ;
66630   Dali::Toolkit::Item *argp2 ;
66631
66632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66633   argp2 = (Dali::Toolkit::Item *)jarg2;
66634   if (!argp2) {
66635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66636     return ;
66637   }
66638   arg2 = *argp2;
66639   arg3 = (float)jarg3;
66640   {
66641     try {
66642       (arg1)->ReplaceItem(arg2,arg3);
66643     } catch (std::out_of_range& e) {
66644       {
66645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66646       };
66647     } catch (std::exception& e) {
66648       {
66649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66650       };
66651     } catch (...) {
66652       {
66653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66654       };
66655     }
66656   }
66657 }
66658
66659
66660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66662   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66663   float arg3 ;
66664
66665   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66666   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66667   if (!arg2) {
66668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66669     return ;
66670   }
66671   arg3 = (float)jarg3;
66672   {
66673     try {
66674       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66675     } catch (std::out_of_range& e) {
66676       {
66677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66678       };
66679     } catch (std::exception& e) {
66680       {
66681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66682       };
66683     } catch (...) {
66684       {
66685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66686       };
66687     }
66688   }
66689 }
66690
66691
66692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66693   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66694   Dali::Vector3 *arg2 = 0 ;
66695
66696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66697   arg2 = (Dali::Vector3 *)jarg2;
66698   if (!arg2) {
66699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66700     return ;
66701   }
66702   {
66703     try {
66704       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66705     } catch (std::out_of_range& e) {
66706       {
66707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66708       };
66709     } catch (std::exception& e) {
66710       {
66711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66712       };
66713     } catch (...) {
66714       {
66715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66716       };
66717     }
66718   }
66719 }
66720
66721
66722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66723   void * jresult ;
66724   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66725   Dali::Vector3 result;
66726
66727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66728   {
66729     try {
66730       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66731     } catch (std::out_of_range& e) {
66732       {
66733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66734       };
66735     } catch (std::exception& e) {
66736       {
66737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66738       };
66739     } catch (...) {
66740       {
66741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66742       };
66743     }
66744   }
66745   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66746   return jresult;
66747 }
66748
66749
66750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66751   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66752   Dali::Vector3 *arg2 = 0 ;
66753
66754   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66755   arg2 = (Dali::Vector3 *)jarg2;
66756   if (!arg2) {
66757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66758     return ;
66759   }
66760   {
66761     try {
66762       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66763     } catch (std::out_of_range& e) {
66764       {
66765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66766       };
66767     } catch (std::exception& e) {
66768       {
66769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66770       };
66771     } catch (...) {
66772       {
66773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66774       };
66775     }
66776   }
66777 }
66778
66779
66780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66781   void * jresult ;
66782   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66783   Dali::Vector3 result;
66784
66785   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66786   {
66787     try {
66788       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66789     } catch (std::out_of_range& e) {
66790       {
66791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66792       };
66793     } catch (std::exception& e) {
66794       {
66795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66796       };
66797     } catch (...) {
66798       {
66799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66800       };
66801     }
66802   }
66803   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66804   return jresult;
66805 }
66806
66807
66808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66809   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66810   Dali::Toolkit::ItemRange *arg2 = 0 ;
66811
66812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66813   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66814   if (!arg2) {
66815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66816     return ;
66817   }
66818   {
66819     try {
66820       (arg1)->GetItemsRange(*arg2);
66821     } catch (std::out_of_range& e) {
66822       {
66823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66824       };
66825     } catch (std::exception& e) {
66826       {
66827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66828       };
66829     } catch (...) {
66830       {
66831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66832       };
66833     }
66834   }
66835 }
66836
66837
66838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66839   void * jresult ;
66840   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66841   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66842
66843   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66844   {
66845     try {
66846       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66847     } catch (std::out_of_range& e) {
66848       {
66849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66850       };
66851     } catch (std::exception& e) {
66852       {
66853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66854       };
66855     } catch (...) {
66856       {
66857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66858       };
66859     }
66860   }
66861   jresult = (void *)result;
66862   return jresult;
66863 }
66864
66865
66866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66867   Dali::Vector3 *arg1 = 0 ;
66868   PropertyInputContainer *arg2 = 0 ;
66869
66870   arg1 = (Dali::Vector3 *)jarg1;
66871   if (!arg1) {
66872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66873     return ;
66874   }
66875   arg2 = (PropertyInputContainer *)jarg2;
66876   if (!arg2) {
66877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66878     return ;
66879   }
66880   {
66881     try {
66882       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66894       };
66895     }
66896   }
66897 }
66898
66899
66900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66901   Dali::Vector3 *arg1 = 0 ;
66902   PropertyInputContainer *arg2 = 0 ;
66903
66904   arg1 = (Dali::Vector3 *)jarg1;
66905   if (!arg1) {
66906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66907     return ;
66908   }
66909   arg2 = (PropertyInputContainer *)jarg2;
66910   if (!arg2) {
66911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66912     return ;
66913   }
66914   {
66915     try {
66916       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66924       };
66925     } catch (...) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66928       };
66929     }
66930   }
66931 }
66932
66933
66934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66935   void * jresult ;
66936   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66937
66938   {
66939     try {
66940       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66941     } catch (std::out_of_range& e) {
66942       {
66943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66944       };
66945     } catch (std::exception& e) {
66946       {
66947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66948       };
66949     } catch (...) {
66950       {
66951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66952       };
66953     }
66954   }
66955   jresult = (void *)result;
66956   return jresult;
66957 }
66958
66959
66960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66961   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66962
66963   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66964   {
66965     try {
66966       delete arg1;
66967     } catch (std::out_of_range& e) {
66968       {
66969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66970       };
66971     } catch (std::exception& e) {
66972       {
66973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66974       };
66975     } catch (...) {
66976       {
66977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66978       };
66979     }
66980   }
66981 }
66982
66983
66984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
66985   void * jresult ;
66986   Dali::Path arg1 ;
66987   Dali::Vector3 *arg2 = 0 ;
66988   Dali::Property::Index arg3 ;
66989   Dali::Vector3 *arg4 = 0 ;
66990   unsigned int arg5 ;
66991   Dali::Path *argp1 ;
66992   Dali::Toolkit::ScrollViewPagePathEffect result;
66993
66994   argp1 = (Dali::Path *)jarg1;
66995   if (!argp1) {
66996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
66997     return 0;
66998   }
66999   arg1 = *argp1;
67000   arg2 = (Dali::Vector3 *)jarg2;
67001   if (!arg2) {
67002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67003     return 0;
67004   }
67005   arg3 = (Dali::Property::Index)jarg3;
67006   arg4 = (Dali::Vector3 *)jarg4;
67007   if (!arg4) {
67008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67009     return 0;
67010   }
67011   arg5 = (unsigned int)jarg5;
67012   {
67013     try {
67014       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
67015     } catch (std::out_of_range& e) {
67016       {
67017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67018       };
67019     } catch (std::exception& e) {
67020       {
67021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67022       };
67023     } catch (...) {
67024       {
67025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67026       };
67027     }
67028   }
67029   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67030   return jresult;
67031 }
67032
67033
67034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67035   void * jresult ;
67036   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67037
67038   {
67039     try {
67040       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67041     } catch (std::out_of_range& e) {
67042       {
67043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (std::exception& e) {
67046       {
67047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67048       };
67049     } catch (...) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67052       };
67053     }
67054   }
67055   jresult = (void *)result;
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67061   void * jresult ;
67062   Dali::BaseHandle arg1 ;
67063   Dali::BaseHandle *argp1 ;
67064   Dali::Toolkit::ScrollViewPagePathEffect result;
67065
67066   argp1 = (Dali::BaseHandle *)jarg1;
67067   if (!argp1) {
67068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67069     return 0;
67070   }
67071   arg1 = *argp1;
67072   {
67073     try {
67074       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67075     } catch (std::out_of_range& e) {
67076       {
67077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67078       };
67079     } catch (std::exception& e) {
67080       {
67081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67082       };
67083     } catch (...) {
67084       {
67085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67086       };
67087     }
67088   }
67089   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67090   return jresult;
67091 }
67092
67093
67094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67095   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67096   Dali::Actor arg2 ;
67097   unsigned int arg3 ;
67098   Dali::Actor *argp2 ;
67099
67100   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67101   argp2 = (Dali::Actor *)jarg2;
67102   if (!argp2) {
67103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67104     return ;
67105   }
67106   arg2 = *argp2;
67107   arg3 = (unsigned int)jarg3;
67108   {
67109     try {
67110       (arg1)->ApplyToPage(arg2,arg3);
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_delete_ScrollViewPagePathEffect(void * jarg1) {
67129   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67130
67131   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67132   {
67133     try {
67134       delete arg1;
67135     } catch (std::out_of_range& e) {
67136       {
67137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67138       };
67139     } catch (std::exception& e) {
67140       {
67141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67142       };
67143     } catch (...) {
67144       {
67145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67146       };
67147     }
67148   }
67149 }
67150
67151
67152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67153   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67154   Dali::Toolkit::ClampState arg2 ;
67155
67156   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67157   arg2 = (Dali::Toolkit::ClampState)jarg2;
67158   if (arg1) (arg1)->x = arg2;
67159 }
67160
67161
67162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67163   int jresult ;
67164   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67165   Dali::Toolkit::ClampState result;
67166
67167   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67168   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67169   jresult = (int)result;
67170   return jresult;
67171 }
67172
67173
67174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67175   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67176   Dali::Toolkit::ClampState arg2 ;
67177
67178   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67179   arg2 = (Dali::Toolkit::ClampState)jarg2;
67180   if (arg1) (arg1)->y = arg2;
67181 }
67182
67183
67184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67185   int jresult ;
67186   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67187   Dali::Toolkit::ClampState result;
67188
67189   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67190   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67191   jresult = (int)result;
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67197   void * jresult ;
67198   Dali::Toolkit::ClampState2D *result = 0 ;
67199
67200   {
67201     try {
67202       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67203     } catch (std::out_of_range& e) {
67204       {
67205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67206       };
67207     } catch (std::exception& e) {
67208       {
67209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67210       };
67211     } catch (...) {
67212       {
67213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67214       };
67215     }
67216   }
67217   jresult = (void *)result;
67218   return jresult;
67219 }
67220
67221
67222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67223   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67224
67225   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67226   {
67227     try {
67228       delete arg1;
67229     } catch (std::out_of_range& e) {
67230       {
67231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67232       };
67233     } catch (std::exception& e) {
67234       {
67235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67236       };
67237     } catch (...) {
67238       {
67239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67240       };
67241     }
67242   }
67243 }
67244
67245
67246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67247   void * jresult ;
67248   float arg1 ;
67249   float arg2 ;
67250   bool arg3 ;
67251   Dali::Toolkit::RulerDomain *result = 0 ;
67252
67253   arg1 = (float)jarg1;
67254   arg2 = (float)jarg2;
67255   arg3 = jarg3 ? true : false;
67256   {
67257     try {
67258       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67259     } catch (std::out_of_range& e) {
67260       {
67261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67262       };
67263     } catch (std::exception& e) {
67264       {
67265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67266       };
67267     } catch (...) {
67268       {
67269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67270       };
67271     }
67272   }
67273   jresult = (void *)result;
67274   return jresult;
67275 }
67276
67277
67278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67279   void * jresult ;
67280   float arg1 ;
67281   float arg2 ;
67282   Dali::Toolkit::RulerDomain *result = 0 ;
67283
67284   arg1 = (float)jarg1;
67285   arg2 = (float)jarg2;
67286   {
67287     try {
67288       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67289     } catch (std::out_of_range& e) {
67290       {
67291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67292       };
67293     } catch (std::exception& e) {
67294       {
67295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67296       };
67297     } catch (...) {
67298       {
67299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67300       };
67301     }
67302   }
67303   jresult = (void *)result;
67304   return jresult;
67305 }
67306
67307
67308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67309   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67310   float arg2 ;
67311
67312   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67313   arg2 = (float)jarg2;
67314   if (arg1) (arg1)->min = arg2;
67315 }
67316
67317
67318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67319   float jresult ;
67320   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67321   float result;
67322
67323   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67324   result = (float) ((arg1)->min);
67325   jresult = result;
67326   return jresult;
67327 }
67328
67329
67330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67331   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67332   float arg2 ;
67333
67334   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67335   arg2 = (float)jarg2;
67336   if (arg1) (arg1)->max = arg2;
67337 }
67338
67339
67340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67341   float jresult ;
67342   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67343   float result;
67344
67345   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67346   result = (float) ((arg1)->max);
67347   jresult = result;
67348   return jresult;
67349 }
67350
67351
67352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67353   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67354   bool arg2 ;
67355
67356   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67357   arg2 = jarg2 ? true : false;
67358   if (arg1) (arg1)->enabled = arg2;
67359 }
67360
67361
67362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67363   unsigned int jresult ;
67364   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67365   bool result;
67366
67367   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67368   result = (bool) ((arg1)->enabled);
67369   jresult = result;
67370   return jresult;
67371 }
67372
67373
67374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67375   float jresult ;
67376   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67377   float arg2 ;
67378   float arg3 ;
67379   float arg4 ;
67380   float result;
67381
67382   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67383   arg2 = (float)jarg2;
67384   arg3 = (float)jarg3;
67385   arg4 = (float)jarg4;
67386   {
67387     try {
67388       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67400       };
67401     }
67402   }
67403   jresult = result;
67404   return jresult;
67405 }
67406
67407
67408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67409   float jresult ;
67410   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67411   float arg2 ;
67412   float arg3 ;
67413   float result;
67414
67415   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67416   arg2 = (float)jarg2;
67417   arg3 = (float)jarg3;
67418   {
67419     try {
67420       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67421     } catch (std::out_of_range& e) {
67422       {
67423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67424       };
67425     } catch (std::exception& e) {
67426       {
67427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67428       };
67429     } catch (...) {
67430       {
67431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67432       };
67433     }
67434   }
67435   jresult = result;
67436   return jresult;
67437 }
67438
67439
67440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67441   float jresult ;
67442   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67443   float arg2 ;
67444   float result;
67445
67446   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67447   arg2 = (float)jarg2;
67448   {
67449     try {
67450       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67451     } catch (std::out_of_range& e) {
67452       {
67453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67454       };
67455     } catch (std::exception& e) {
67456       {
67457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67458       };
67459     } catch (...) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67462       };
67463     }
67464   }
67465   jresult = result;
67466   return jresult;
67467 }
67468
67469
67470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67471   float jresult ;
67472   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67473   float arg2 ;
67474   float arg3 ;
67475   float arg4 ;
67476   Dali::Toolkit::ClampState *arg5 = 0 ;
67477   float result;
67478
67479   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67480   arg2 = (float)jarg2;
67481   arg3 = (float)jarg3;
67482   arg4 = (float)jarg4;
67483   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67484   if (!arg5) {
67485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67486     return 0;
67487   }
67488   {
67489     try {
67490       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67491     } catch (std::out_of_range& e) {
67492       {
67493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67494       };
67495     } catch (std::exception& e) {
67496       {
67497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (...) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67502       };
67503     }
67504   }
67505   jresult = result;
67506   return jresult;
67507 }
67508
67509
67510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67511   float jresult ;
67512   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67513   float result;
67514
67515   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67516   {
67517     try {
67518       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67519     } catch (std::out_of_range& e) {
67520       {
67521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67522       };
67523     } catch (std::exception& e) {
67524       {
67525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (...) {
67528       {
67529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67530       };
67531     }
67532   }
67533   jresult = result;
67534   return jresult;
67535 }
67536
67537
67538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67539   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67540
67541   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67542   {
67543     try {
67544       delete arg1;
67545     } catch (std::out_of_range& e) {
67546       {
67547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67548       };
67549     } catch (std::exception& e) {
67550       {
67551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67552       };
67553     } catch (...) {
67554       {
67555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67556       };
67557     }
67558   }
67559 }
67560
67561
67562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67563   float jresult ;
67564   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67565   float arg2 ;
67566   float arg3 ;
67567   float result;
67568
67569   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67570   arg2 = (float)jarg2;
67571   arg3 = (float)jarg3;
67572   {
67573     try {
67574       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67575     } catch (std::out_of_range& e) {
67576       {
67577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67578       };
67579     } catch (std::exception& e) {
67580       {
67581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67582       };
67583     } catch (...) {
67584       {
67585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67586       };
67587     }
67588   }
67589   jresult = result;
67590   return jresult;
67591 }
67592
67593
67594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67595   float jresult ;
67596   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67597   float arg2 ;
67598   float result;
67599
67600   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67601   arg2 = (float)jarg2;
67602   {
67603     try {
67604       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67605     } catch (std::out_of_range& e) {
67606       {
67607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67608       };
67609     } catch (std::exception& e) {
67610       {
67611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67612       };
67613     } catch (...) {
67614       {
67615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67616       };
67617     }
67618   }
67619   jresult = result;
67620   return jresult;
67621 }
67622
67623
67624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67625   float jresult ;
67626   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67627   unsigned int arg2 ;
67628   unsigned int *arg3 = 0 ;
67629   bool arg4 ;
67630   float result;
67631
67632   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67633   arg2 = (unsigned int)jarg2;
67634   arg3 = (unsigned int *)jarg3;
67635   arg4 = jarg4 ? true : false;
67636   {
67637     try {
67638       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67639     } catch (std::out_of_range& e) {
67640       {
67641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67642       };
67643     } catch (std::exception& e) {
67644       {
67645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67646       };
67647     } catch (...) {
67648       {
67649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67650       };
67651     }
67652   }
67653   jresult = result;
67654   return jresult;
67655 }
67656
67657
67658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67659   unsigned int jresult ;
67660   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67661   float arg2 ;
67662   bool arg3 ;
67663   unsigned int result;
67664
67665   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67666   arg2 = (float)jarg2;
67667   arg3 = jarg3 ? true : false;
67668   {
67669     try {
67670       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67671     } catch (std::out_of_range& e) {
67672       {
67673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67674       };
67675     } catch (std::exception& e) {
67676       {
67677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67678       };
67679     } catch (...) {
67680       {
67681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67682       };
67683     }
67684   }
67685   jresult = result;
67686   return jresult;
67687 }
67688
67689
67690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67691   unsigned int jresult ;
67692   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67693   unsigned int result;
67694
67695   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67696   {
67697     try {
67698       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67699     } catch (std::out_of_range& e) {
67700       {
67701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67702       };
67703     } catch (std::exception& e) {
67704       {
67705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67706       };
67707     } catch (...) {
67708       {
67709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67710       };
67711     }
67712   }
67713   jresult = result;
67714   return jresult;
67715 }
67716
67717
67718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67719   int jresult ;
67720   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67721   Dali::Toolkit::Ruler::RulerType result;
67722
67723   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67724   {
67725     try {
67726       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67727     } catch (std::out_of_range& e) {
67728       {
67729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (std::exception& e) {
67732       {
67733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (...) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67738       };
67739     }
67740   }
67741   jresult = (int)result;
67742   return jresult;
67743 }
67744
67745
67746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67747   unsigned int jresult ;
67748   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67749   bool result;
67750
67751   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67752   {
67753     try {
67754       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67755     } catch (std::out_of_range& e) {
67756       {
67757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67758       };
67759     } catch (std::exception& e) {
67760       {
67761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67762       };
67763     } catch (...) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67766       };
67767     }
67768   }
67769   jresult = result;
67770   return jresult;
67771 }
67772
67773
67774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67775   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67776
67777   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67778   {
67779     try {
67780       (arg1)->Enable();
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_Disable(void * jarg1) {
67799   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67800
67801   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67802   {
67803     try {
67804       (arg1)->Disable();
67805     } catch (std::out_of_range& e) {
67806       {
67807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67808       };
67809     } catch (std::exception& e) {
67810       {
67811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67812       };
67813     } catch (...) {
67814       {
67815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67816       };
67817     }
67818   }
67819 }
67820
67821
67822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67823   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67824   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67825   Dali::Toolkit::RulerDomain *argp2 ;
67826
67827   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67828   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67829   if (!argp2) {
67830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67831     return ;
67832   }
67833   arg2 = *argp2;
67834   {
67835     try {
67836       (arg1)->SetDomain(arg2);
67837     } catch (std::out_of_range& e) {
67838       {
67839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67840       };
67841     } catch (std::exception& e) {
67842       {
67843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67844       };
67845     } catch (...) {
67846       {
67847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67848       };
67849     }
67850   }
67851 }
67852
67853
67854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67855   void * jresult ;
67856   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67857   Dali::Toolkit::RulerDomain *result = 0 ;
67858
67859   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67860   {
67861     try {
67862       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67863     } catch (std::out_of_range& e) {
67864       {
67865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67866       };
67867     } catch (std::exception& e) {
67868       {
67869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67870       };
67871     } catch (...) {
67872       {
67873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67874       };
67875     }
67876   }
67877   jresult = (void *)result;
67878   return jresult;
67879 }
67880
67881
67882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67884
67885   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67886   {
67887     try {
67888       (arg1)->DisableDomain();
67889     } catch (std::out_of_range& e) {
67890       {
67891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67892       };
67893     } catch (std::exception& e) {
67894       {
67895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67896       };
67897     } catch (...) {
67898       {
67899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67900       };
67901     }
67902   }
67903 }
67904
67905
67906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67907   float jresult ;
67908   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67909   float arg2 ;
67910   float arg3 ;
67911   float arg4 ;
67912   float result;
67913
67914   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67915   arg2 = (float)jarg2;
67916   arg3 = (float)jarg3;
67917   arg4 = (float)jarg4;
67918   {
67919     try {
67920       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67921     } catch (std::out_of_range& e) {
67922       {
67923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67924       };
67925     } catch (std::exception& e) {
67926       {
67927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (...) {
67930       {
67931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67932       };
67933     }
67934   }
67935   jresult = result;
67936   return jresult;
67937 }
67938
67939
67940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67941   float jresult ;
67942   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67943   float arg2 ;
67944   float arg3 ;
67945   float result;
67946
67947   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67948   arg2 = (float)jarg2;
67949   arg3 = (float)jarg3;
67950   {
67951     try {
67952       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67953     } catch (std::out_of_range& e) {
67954       {
67955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67956       };
67957     } catch (std::exception& e) {
67958       {
67959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67960       };
67961     } catch (...) {
67962       {
67963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67964       };
67965     }
67966   }
67967   jresult = result;
67968   return jresult;
67969 }
67970
67971
67972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67973   float jresult ;
67974   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67975   float arg2 ;
67976   float result;
67977
67978   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67979   arg2 = (float)jarg2;
67980   {
67981     try {
67982       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
67983     } catch (std::out_of_range& e) {
67984       {
67985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67986       };
67987     } catch (std::exception& e) {
67988       {
67989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67990       };
67991     } catch (...) {
67992       {
67993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67994       };
67995     }
67996   }
67997   jresult = result;
67998   return jresult;
67999 }
68000
68001
68002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68003   float jresult ;
68004   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68005   float arg2 ;
68006   float arg3 ;
68007   float arg4 ;
68008   Dali::Toolkit::ClampState *arg5 = 0 ;
68009   float result;
68010
68011   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68012   arg2 = (float)jarg2;
68013   arg3 = (float)jarg3;
68014   arg4 = (float)jarg4;
68015   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68016   if (!arg5) {
68017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68018     return 0;
68019   }
68020   {
68021     try {
68022       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68023     } catch (std::out_of_range& e) {
68024       {
68025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68026       };
68027     } catch (std::exception& e) {
68028       {
68029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68030       };
68031     } catch (...) {
68032       {
68033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68034       };
68035     }
68036   }
68037   jresult = result;
68038   return jresult;
68039 }
68040
68041
68042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68043   float jresult ;
68044   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68045   float arg2 ;
68046   float arg3 ;
68047   float arg4 ;
68048   float arg5 ;
68049   float result;
68050
68051   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68052   arg2 = (float)jarg2;
68053   arg3 = (float)jarg3;
68054   arg4 = (float)jarg4;
68055   arg5 = (float)jarg5;
68056   {
68057     try {
68058       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68059     } catch (std::out_of_range& e) {
68060       {
68061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68062       };
68063     } catch (std::exception& e) {
68064       {
68065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68066       };
68067     } catch (...) {
68068       {
68069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68070       };
68071     }
68072   }
68073   jresult = result;
68074   return jresult;
68075 }
68076
68077
68078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68079   float jresult ;
68080   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68081   float arg2 ;
68082   float arg3 ;
68083   float arg4 ;
68084   float result;
68085
68086   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68087   arg2 = (float)jarg2;
68088   arg3 = (float)jarg3;
68089   arg4 = (float)jarg4;
68090   {
68091     try {
68092       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68093     } catch (std::out_of_range& e) {
68094       {
68095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68096       };
68097     } catch (std::exception& e) {
68098       {
68099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68104       };
68105     }
68106   }
68107   jresult = result;
68108   return jresult;
68109 }
68110
68111
68112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68113   float jresult ;
68114   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68115   float arg2 ;
68116   float arg3 ;
68117   float result;
68118
68119   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68120   arg2 = (float)jarg2;
68121   arg3 = (float)jarg3;
68122   {
68123     try {
68124       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68125     } catch (std::out_of_range& e) {
68126       {
68127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68128       };
68129     } catch (std::exception& e) {
68130       {
68131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68132       };
68133     } catch (...) {
68134       {
68135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68136       };
68137     }
68138   }
68139   jresult = result;
68140   return jresult;
68141 }
68142
68143
68144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68145   float jresult ;
68146   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68147   float arg2 ;
68148   float result;
68149
68150   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68151   arg2 = (float)jarg2;
68152   {
68153     try {
68154       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68155     } catch (std::out_of_range& e) {
68156       {
68157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68158       };
68159     } catch (std::exception& e) {
68160       {
68161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68162       };
68163     } catch (...) {
68164       {
68165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68166       };
68167     }
68168   }
68169   jresult = result;
68170   return jresult;
68171 }
68172
68173
68174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68175   float jresult ;
68176   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68177   float arg2 ;
68178   float arg3 ;
68179   float arg4 ;
68180   float arg5 ;
68181   Dali::Toolkit::ClampState *arg6 = 0 ;
68182   float result;
68183
68184   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68185   arg2 = (float)jarg2;
68186   arg3 = (float)jarg3;
68187   arg4 = (float)jarg4;
68188   arg5 = (float)jarg5;
68189   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68190   if (!arg6) {
68191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68192     return 0;
68193   }
68194   {
68195     try {
68196       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68197     } catch (std::out_of_range& e) {
68198       {
68199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68200       };
68201     } catch (std::exception& e) {
68202       {
68203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68204       };
68205     } catch (...) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68208       };
68209     }
68210   }
68211   jresult = result;
68212   return jresult;
68213 }
68214
68215
68216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68217   void * jresult ;
68218   Dali::Toolkit::DefaultRuler *result = 0 ;
68219
68220   {
68221     try {
68222       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68223     } catch (std::out_of_range& e) {
68224       {
68225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68226       };
68227     } catch (std::exception& e) {
68228       {
68229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68230       };
68231     } catch (...) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68234       };
68235     }
68236   }
68237   jresult = (void *)result;
68238   return jresult;
68239 }
68240
68241
68242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68243   float jresult ;
68244   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68245   float arg2 ;
68246   float arg3 ;
68247   float result;
68248
68249   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68250   arg2 = (float)jarg2;
68251   arg3 = (float)jarg3;
68252   {
68253     try {
68254       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68255     } catch (std::out_of_range& e) {
68256       {
68257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68258       };
68259     } catch (std::exception& e) {
68260       {
68261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68262       };
68263     } catch (...) {
68264       {
68265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68266       };
68267     }
68268   }
68269   jresult = result;
68270   return jresult;
68271 }
68272
68273
68274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68275   float jresult ;
68276   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68277   unsigned int arg2 ;
68278   unsigned int *arg3 = 0 ;
68279   bool arg4 ;
68280   float result;
68281
68282   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68283   arg2 = (unsigned int)jarg2;
68284   arg3 = (unsigned int *)jarg3;
68285   arg4 = jarg4 ? true : false;
68286   {
68287     try {
68288       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (...) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68300       };
68301     }
68302   }
68303   jresult = result;
68304   return jresult;
68305 }
68306
68307
68308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68309   unsigned int jresult ;
68310   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68311   float arg2 ;
68312   bool arg3 ;
68313   unsigned int result;
68314
68315   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68316   arg2 = (float)jarg2;
68317   arg3 = jarg3 ? true : false;
68318   {
68319     try {
68320       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68321     } catch (std::out_of_range& e) {
68322       {
68323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68324       };
68325     } catch (std::exception& e) {
68326       {
68327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68328       };
68329     } catch (...) {
68330       {
68331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68332       };
68333     }
68334   }
68335   jresult = result;
68336   return jresult;
68337 }
68338
68339
68340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68341   unsigned int jresult ;
68342   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68343   unsigned int result;
68344
68345   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68346   {
68347     try {
68348       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68349     } catch (std::out_of_range& e) {
68350       {
68351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68352       };
68353     } catch (std::exception& e) {
68354       {
68355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68356       };
68357     } catch (...) {
68358       {
68359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68360       };
68361     }
68362   }
68363   jresult = result;
68364   return jresult;
68365 }
68366
68367
68368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68369   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68370
68371   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68372   {
68373     try {
68374       delete arg1;
68375     } catch (std::out_of_range& e) {
68376       {
68377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68378       };
68379     } catch (std::exception& e) {
68380       {
68381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68382       };
68383     } catch (...) {
68384       {
68385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68386       };
68387     }
68388   }
68389 }
68390
68391
68392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68393   void * jresult ;
68394   float arg1 ;
68395   Dali::Toolkit::FixedRuler *result = 0 ;
68396
68397   arg1 = (float)jarg1;
68398   {
68399     try {
68400       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68401     } catch (std::out_of_range& e) {
68402       {
68403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68404       };
68405     } catch (std::exception& e) {
68406       {
68407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (...) {
68410       {
68411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68412       };
68413     }
68414   }
68415   jresult = (void *)result;
68416   return jresult;
68417 }
68418
68419
68420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68421   void * jresult ;
68422   Dali::Toolkit::FixedRuler *result = 0 ;
68423
68424   {
68425     try {
68426       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68427     } catch (std::out_of_range& e) {
68428       {
68429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68430       };
68431     } catch (std::exception& e) {
68432       {
68433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (...) {
68436       {
68437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68438       };
68439     }
68440   }
68441   jresult = (void *)result;
68442   return jresult;
68443 }
68444
68445
68446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68447   float jresult ;
68448   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68449   float arg2 ;
68450   float arg3 ;
68451   float result;
68452
68453   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68454   arg2 = (float)jarg2;
68455   arg3 = (float)jarg3;
68456   {
68457     try {
68458       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68459     } catch (std::out_of_range& e) {
68460       {
68461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68462       };
68463     } catch (std::exception& e) {
68464       {
68465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68466       };
68467     } catch (...) {
68468       {
68469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68470       };
68471     }
68472   }
68473   jresult = result;
68474   return jresult;
68475 }
68476
68477
68478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68479   float jresult ;
68480   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68481   unsigned int arg2 ;
68482   unsigned int *arg3 = 0 ;
68483   bool arg4 ;
68484   float result;
68485
68486   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68487   arg2 = (unsigned int)jarg2;
68488   arg3 = (unsigned int *)jarg3;
68489   arg4 = jarg4 ? true : false;
68490   {
68491     try {
68492       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68493     } catch (std::out_of_range& e) {
68494       {
68495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68496       };
68497     } catch (std::exception& e) {
68498       {
68499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (...) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68504       };
68505     }
68506   }
68507   jresult = result;
68508   return jresult;
68509 }
68510
68511
68512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68513   unsigned int jresult ;
68514   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68515   float arg2 ;
68516   bool arg3 ;
68517   unsigned int result;
68518
68519   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68520   arg2 = (float)jarg2;
68521   arg3 = jarg3 ? true : false;
68522   {
68523     try {
68524       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68525     } catch (std::out_of_range& e) {
68526       {
68527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68528       };
68529     } catch (std::exception& e) {
68530       {
68531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (...) {
68534       {
68535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68536       };
68537     }
68538   }
68539   jresult = result;
68540   return jresult;
68541 }
68542
68543
68544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68545   unsigned int jresult ;
68546   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68547   unsigned int result;
68548
68549   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68550   {
68551     try {
68552       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68553     } catch (std::out_of_range& e) {
68554       {
68555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68556       };
68557     } catch (std::exception& e) {
68558       {
68559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68560       };
68561     } catch (...) {
68562       {
68563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68564       };
68565     }
68566   }
68567   jresult = result;
68568   return jresult;
68569 }
68570
68571
68572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68573   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68574
68575   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68576   {
68577     try {
68578       delete arg1;
68579     } catch (std::out_of_range& e) {
68580       {
68581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68582       };
68583     } catch (std::exception& e) {
68584       {
68585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68590       };
68591     }
68592   }
68593 }
68594
68595
68596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68597   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68598   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68599
68600   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68601   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68602   if (arg1) (arg1)->scale = *arg2;
68603 }
68604
68605
68606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68607   void * jresult ;
68608   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68609   Dali::Toolkit::ClampState2D *result = 0 ;
68610
68611   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68612   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68613   jresult = (void *)result;
68614   return jresult;
68615 }
68616
68617
68618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68619   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68620   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68621
68622   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68623   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68624   if (arg1) (arg1)->position = *arg2;
68625 }
68626
68627
68628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68629   void * jresult ;
68630   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68631   Dali::Toolkit::ClampState2D *result = 0 ;
68632
68633   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68634   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68635   jresult = (void *)result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68641   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68642   Dali::Toolkit::ClampState arg2 ;
68643
68644   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68645   arg2 = (Dali::Toolkit::ClampState)jarg2;
68646   if (arg1) (arg1)->rotation = arg2;
68647 }
68648
68649
68650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68651   int jresult ;
68652   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68653   Dali::Toolkit::ClampState result;
68654
68655   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68656   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68657   jresult = (int)result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68663   void * jresult ;
68664   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68665
68666   {
68667     try {
68668       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68669     } catch (std::out_of_range& e) {
68670       {
68671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68672       };
68673     } catch (std::exception& e) {
68674       {
68675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68676       };
68677     } catch (...) {
68678       {
68679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68680       };
68681     }
68682   }
68683   jresult = (void *)result;
68684   return jresult;
68685 }
68686
68687
68688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68689   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68690
68691   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68692   {
68693     try {
68694       delete arg1;
68695     } catch (std::out_of_range& e) {
68696       {
68697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68698       };
68699     } catch (std::exception& e) {
68700       {
68701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68702       };
68703     } catch (...) {
68704       {
68705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68706       };
68707     }
68708   }
68709 }
68710
68711
68712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68713   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68714   Dali::Toolkit::SnapType arg2 ;
68715
68716   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68717   arg2 = (Dali::Toolkit::SnapType)jarg2;
68718   if (arg1) (arg1)->type = arg2;
68719 }
68720
68721
68722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68723   int jresult ;
68724   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68725   Dali::Toolkit::SnapType result;
68726
68727   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68728   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68729   jresult = (int)result;
68730   return jresult;
68731 }
68732
68733
68734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68735   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68736   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68737
68738   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68739   arg2 = (Dali::Vector2 *)jarg2;
68740   if (arg1) (arg1)->position = *arg2;
68741 }
68742
68743
68744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68745   void * jresult ;
68746   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68747   Dali::Vector2 *result = 0 ;
68748
68749   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68750   result = (Dali::Vector2 *)& ((arg1)->position);
68751   jresult = (void *)result;
68752   return jresult;
68753 }
68754
68755
68756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68757   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68758   float arg2 ;
68759
68760   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68761   arg2 = (float)jarg2;
68762   if (arg1) (arg1)->duration = arg2;
68763 }
68764
68765
68766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68767   float jresult ;
68768   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68769   float result;
68770
68771   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68772   result = (float) ((arg1)->duration);
68773   jresult = result;
68774   return jresult;
68775 }
68776
68777
68778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68779   void * jresult ;
68780   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68781
68782   {
68783     try {
68784       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68785     } catch (std::out_of_range& e) {
68786       {
68787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68788       };
68789     } catch (std::exception& e) {
68790       {
68791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68792       };
68793     } catch (...) {
68794       {
68795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68796       };
68797     }
68798   }
68799   jresult = (void *)result;
68800   return jresult;
68801 }
68802
68803
68804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68805   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68806
68807   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68808   {
68809     try {
68810       delete arg1;
68811     } catch (std::out_of_range& e) {
68812       {
68813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68814       };
68815     } catch (std::exception& e) {
68816       {
68817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68818       };
68819     } catch (...) {
68820       {
68821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68822       };
68823     }
68824   }
68825 }
68826
68827
68828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68829   int jresult ;
68830   int result;
68831
68832   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68833   jresult = (int)result;
68834   return jresult;
68835 }
68836
68837
68838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68839   int jresult ;
68840   int result;
68841
68842   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68843   jresult = (int)result;
68844   return jresult;
68845 }
68846
68847
68848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68849   int jresult ;
68850   int result;
68851
68852   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68853   jresult = (int)result;
68854   return jresult;
68855 }
68856
68857
68858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68859   int jresult ;
68860   int result;
68861
68862   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68863   jresult = (int)result;
68864   return jresult;
68865 }
68866
68867
68868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68869   int jresult ;
68870   int result;
68871
68872   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
68873   jresult = (int)result;
68874   return jresult;
68875 }
68876
68877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68878   int jresult ;
68879   int result;
68880
68881   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68882   jresult = (int)result;
68883   return jresult;
68884 }
68885
68886
68887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68888   int jresult ;
68889   int result;
68890
68891   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68892   jresult = (int)result;
68893   return jresult;
68894 }
68895
68896
68897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68898   int jresult ;
68899   int result;
68900
68901   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68902   jresult = (int)result;
68903   return jresult;
68904 }
68905
68906
68907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68908   int jresult ;
68909   int result;
68910
68911   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68912   jresult = (int)result;
68913   return jresult;
68914 }
68915
68916
68917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68918   int jresult ;
68919   int result;
68920
68921   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68922   jresult = (int)result;
68923   return jresult;
68924 }
68925
68926
68927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68928   int jresult ;
68929   int result;
68930
68931   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68932   jresult = (int)result;
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68938   int jresult ;
68939   int result;
68940
68941   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68942   jresult = (int)result;
68943   return jresult;
68944 }
68945
68946
68947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68948   int jresult ;
68949   int result;
68950
68951   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68952   jresult = (int)result;
68953   return jresult;
68954 }
68955
68956
68957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68958   int jresult ;
68959   int result;
68960
68961   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68962   jresult = (int)result;
68963   return jresult;
68964 }
68965
68966
68967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68968   int jresult ;
68969   int result;
68970
68971   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68972   jresult = (int)result;
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68978   int jresult ;
68979   int result;
68980
68981   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
68982   jresult = (int)result;
68983   return jresult;
68984 }
68985
68986
68987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
68988   int jresult ;
68989   int result;
68990
68991   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
68992   jresult = (int)result;
68993   return jresult;
68994 }
68995
68996
68997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
68998   int jresult ;
68999   int result;
69000
69001   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
69002   jresult = (int)result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69008   int jresult ;
69009   int result;
69010
69011   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69012   jresult = (int)result;
69013   return jresult;
69014 }
69015
69016
69017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69018   int jresult ;
69019   int result;
69020
69021   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69022   jresult = (int)result;
69023   return jresult;
69024 }
69025
69026
69027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69028   int jresult ;
69029   int result;
69030
69031   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69032   jresult = (int)result;
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69038   int jresult ;
69039   int result;
69040
69041   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69042   jresult = (int)result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69048   int jresult ;
69049   int result;
69050
69051   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69052   jresult = (int)result;
69053   return jresult;
69054 }
69055
69056
69057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69058   int jresult ;
69059   int result;
69060
69061   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69062   jresult = (int)result;
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69068   int jresult ;
69069   int result;
69070
69071   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69072   jresult = (int)result;
69073   return jresult;
69074 }
69075
69076
69077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69078   int jresult ;
69079   int result;
69080
69081   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69082   jresult = (int)result;
69083   return jresult;
69084 }
69085
69086
69087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69088   void * jresult ;
69089   Dali::Toolkit::ScrollView::Property *result = 0 ;
69090
69091   {
69092     try {
69093       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69094     } catch (std::out_of_range& e) {
69095       {
69096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69097       };
69098     } catch (std::exception& e) {
69099       {
69100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69101       };
69102     } catch (...) {
69103       {
69104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69105       };
69106     }
69107   }
69108   jresult = (void *)result;
69109   return jresult;
69110 }
69111
69112
69113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69114   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69115
69116   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69117   {
69118     try {
69119       delete arg1;
69120     } catch (std::out_of_range& e) {
69121       {
69122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69123       };
69124     } catch (std::exception& e) {
69125       {
69126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69127       };
69128     } catch (...) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69131       };
69132     }
69133   }
69134 }
69135
69136
69137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69138   void * jresult ;
69139   Dali::Toolkit::ScrollView *result = 0 ;
69140
69141   {
69142     try {
69143       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69144     } catch (std::out_of_range& e) {
69145       {
69146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69147       };
69148     } catch (std::exception& e) {
69149       {
69150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69151       };
69152     } catch (...) {
69153       {
69154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69155       };
69156     }
69157   }
69158   jresult = (void *)result;
69159   return jresult;
69160 }
69161
69162
69163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69164   void * jresult ;
69165   Dali::Toolkit::ScrollView *arg1 = 0 ;
69166   Dali::Toolkit::ScrollView *result = 0 ;
69167
69168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69169   if (!arg1) {
69170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69171     return 0;
69172   }
69173   {
69174     try {
69175       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69176     } catch (std::out_of_range& e) {
69177       {
69178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69179       };
69180     } catch (std::exception& e) {
69181       {
69182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69183       };
69184     } catch (...) {
69185       {
69186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69187       };
69188     }
69189   }
69190   jresult = (void *)result;
69191   return jresult;
69192 }
69193
69194
69195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69196   void * jresult ;
69197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69198   Dali::Toolkit::ScrollView *arg2 = 0 ;
69199   Dali::Toolkit::ScrollView *result = 0 ;
69200
69201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69202   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69203   if (!arg2) {
69204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69205     return 0;
69206   }
69207   {
69208     try {
69209       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69210     } catch (std::out_of_range& e) {
69211       {
69212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69213       };
69214     } catch (std::exception& e) {
69215       {
69216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69217       };
69218     } catch (...) {
69219       {
69220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69221       };
69222     }
69223   }
69224   jresult = (void *)result;
69225   return jresult;
69226 }
69227
69228
69229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69230   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69231
69232   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69233   {
69234     try {
69235       delete arg1;
69236     } catch (std::out_of_range& e) {
69237       {
69238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69239       };
69240     } catch (std::exception& e) {
69241       {
69242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69243       };
69244     } catch (...) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69247       };
69248     }
69249   }
69250 }
69251
69252
69253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69254   void * jresult ;
69255   Dali::Toolkit::ScrollView result;
69256
69257   {
69258     try {
69259       result = Dali::Toolkit::ScrollView::New();
69260     } catch (std::out_of_range& e) {
69261       {
69262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69263       };
69264     } catch (std::exception& e) {
69265       {
69266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69267       };
69268     } catch (...) {
69269       {
69270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69271       };
69272     }
69273   }
69274   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69275   return jresult;
69276 }
69277
69278
69279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69280   void * jresult ;
69281   Dali::BaseHandle arg1 ;
69282   Dali::BaseHandle *argp1 ;
69283   Dali::Toolkit::ScrollView result;
69284
69285   argp1 = (Dali::BaseHandle *)jarg1;
69286   if (!argp1) {
69287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69288     return 0;
69289   }
69290   arg1 = *argp1;
69291   {
69292     try {
69293       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69294     } catch (std::out_of_range& e) {
69295       {
69296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69297       };
69298     } catch (std::exception& e) {
69299       {
69300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69301       };
69302     } catch (...) {
69303       {
69304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69305       };
69306     }
69307   }
69308   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69309   return jresult;
69310 }
69311
69312
69313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69314   void * jresult ;
69315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69316   Dali::AlphaFunction result;
69317
69318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69319   {
69320     try {
69321       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69322     } catch (std::out_of_range& e) {
69323       {
69324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69325       };
69326     } catch (std::exception& e) {
69327       {
69328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69329       };
69330     } catch (...) {
69331       {
69332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69333       };
69334     }
69335   }
69336   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69337   return jresult;
69338 }
69339
69340
69341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69343   Dali::AlphaFunction arg2 ;
69344   Dali::AlphaFunction *argp2 ;
69345
69346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69347   argp2 = (Dali::AlphaFunction *)jarg2;
69348   if (!argp2) {
69349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69350     return ;
69351   }
69352   arg2 = *argp2;
69353   {
69354     try {
69355       (arg1)->SetScrollSnapAlphaFunction(arg2);
69356     } catch (std::out_of_range& e) {
69357       {
69358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69359       };
69360     } catch (std::exception& e) {
69361       {
69362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69363       };
69364     } catch (...) {
69365       {
69366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69367       };
69368     }
69369   }
69370 }
69371
69372
69373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69374   void * jresult ;
69375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69376   Dali::AlphaFunction result;
69377
69378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69379   {
69380     try {
69381       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69382     } catch (std::out_of_range& e) {
69383       {
69384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69385       };
69386     } catch (std::exception& e) {
69387       {
69388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69389       };
69390     } catch (...) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69393       };
69394     }
69395   }
69396   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69397   return jresult;
69398 }
69399
69400
69401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69403   Dali::AlphaFunction arg2 ;
69404   Dali::AlphaFunction *argp2 ;
69405
69406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69407   argp2 = (Dali::AlphaFunction *)jarg2;
69408   if (!argp2) {
69409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69410     return ;
69411   }
69412   arg2 = *argp2;
69413   {
69414     try {
69415       (arg1)->SetScrollFlickAlphaFunction(arg2);
69416     } catch (std::out_of_range& e) {
69417       {
69418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69419       };
69420     } catch (std::exception& e) {
69421       {
69422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69423       };
69424     } catch (...) {
69425       {
69426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69427       };
69428     }
69429   }
69430 }
69431
69432
69433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69434   float jresult ;
69435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69436   float result;
69437
69438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69439   {
69440     try {
69441       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69442     } catch (std::out_of_range& e) {
69443       {
69444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69445       };
69446     } catch (std::exception& e) {
69447       {
69448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69449       };
69450     } catch (...) {
69451       {
69452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69453       };
69454     }
69455   }
69456   jresult = result;
69457   return jresult;
69458 }
69459
69460
69461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69463   float arg2 ;
69464
69465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69466   arg2 = (float)jarg2;
69467   {
69468     try {
69469       (arg1)->SetScrollSnapDuration(arg2);
69470     } catch (std::out_of_range& e) {
69471       {
69472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69473       };
69474     } catch (std::exception& e) {
69475       {
69476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69477       };
69478     } catch (...) {
69479       {
69480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69481       };
69482     }
69483   }
69484 }
69485
69486
69487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69488   float jresult ;
69489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69490   float result;
69491
69492   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69493   {
69494     try {
69495       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69496     } catch (std::out_of_range& e) {
69497       {
69498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69499       };
69500     } catch (std::exception& e) {
69501       {
69502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (...) {
69505       {
69506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69507       };
69508     }
69509   }
69510   jresult = result;
69511   return jresult;
69512 }
69513
69514
69515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69516   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69517   float arg2 ;
69518
69519   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69520   arg2 = (float)jarg2;
69521   {
69522     try {
69523       (arg1)->SetScrollFlickDuration(arg2);
69524     } catch (std::out_of_range& e) {
69525       {
69526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69527       };
69528     } catch (std::exception& e) {
69529       {
69530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69531       };
69532     } catch (...) {
69533       {
69534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69535       };
69536     }
69537   }
69538 }
69539
69540
69541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69543   Dali::Toolkit::RulerPtr arg2 ;
69544   Dali::Toolkit::RulerPtr *argp2 ;
69545
69546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69547   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69548   if (!argp2) {
69549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69550     return ;
69551   }
69552   arg2 = *argp2;
69553   {
69554     try {
69555       (arg1)->SetRulerX(arg2);
69556     } catch (std::out_of_range& e) {
69557       {
69558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69559       };
69560     } catch (std::exception& e) {
69561       {
69562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69563       };
69564     } catch (...) {
69565       {
69566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69567       };
69568     }
69569   }
69570 }
69571
69572
69573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69575   Dali::Toolkit::RulerPtr arg2 ;
69576   Dali::Toolkit::RulerPtr *argp2 ;
69577
69578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69579   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69580   if (!argp2) {
69581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69582     return ;
69583   }
69584   arg2 = *argp2;
69585   {
69586     try {
69587       (arg1)->SetRulerY(arg2);
69588     } catch (std::out_of_range& e) {
69589       {
69590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69591       };
69592     } catch (std::exception& e) {
69593       {
69594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69595       };
69596     } catch (...) {
69597       {
69598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69599       };
69600     }
69601   }
69602 }
69603
69604
69605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69607   bool arg2 ;
69608
69609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69610   arg2 = jarg2 ? true : false;
69611   {
69612     try {
69613       (arg1)->SetScrollSensitive(arg2);
69614     } catch (std::out_of_range& e) {
69615       {
69616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69617       };
69618     } catch (std::exception& e) {
69619       {
69620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69621       };
69622     } catch (...) {
69623       {
69624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69625       };
69626     }
69627   }
69628 }
69629
69630
69631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69632   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69633   float arg2 ;
69634   float arg3 ;
69635
69636   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69637   arg2 = (float)jarg2;
69638   arg3 = (float)jarg3;
69639   {
69640     try {
69641       (arg1)->SetMaxOvershoot(arg2,arg3);
69642     } catch (std::out_of_range& e) {
69643       {
69644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69645       };
69646     } catch (std::exception& e) {
69647       {
69648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69649       };
69650     } catch (...) {
69651       {
69652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69653       };
69654     }
69655   }
69656 }
69657
69658
69659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69661   Dali::AlphaFunction arg2 ;
69662   Dali::AlphaFunction *argp2 ;
69663
69664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69665   argp2 = (Dali::AlphaFunction *)jarg2;
69666   if (!argp2) {
69667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69668     return ;
69669   }
69670   arg2 = *argp2;
69671   {
69672     try {
69673       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69674     } catch (std::out_of_range& e) {
69675       {
69676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69677       };
69678     } catch (std::exception& e) {
69679       {
69680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69681       };
69682     } catch (...) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69685       };
69686     }
69687   }
69688 }
69689
69690
69691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69693   float arg2 ;
69694
69695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69696   arg2 = (float)jarg2;
69697   {
69698     try {
69699       (arg1)->SetSnapOvershootDuration(arg2);
69700     } catch (std::out_of_range& e) {
69701       {
69702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69703       };
69704     } catch (std::exception& e) {
69705       {
69706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69707       };
69708     } catch (...) {
69709       {
69710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69711       };
69712     }
69713   }
69714 }
69715
69716
69717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69719   bool arg2 ;
69720
69721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69722   arg2 = jarg2 ? true : false;
69723   {
69724     try {
69725       (arg1)->SetActorAutoSnap(arg2);
69726     } catch (std::out_of_range& e) {
69727       {
69728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69729       };
69730     } catch (std::exception& e) {
69731       {
69732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69733       };
69734     } catch (...) {
69735       {
69736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69737       };
69738     }
69739   }
69740 }
69741
69742
69743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69744   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69745   bool arg2 ;
69746
69747   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69748   arg2 = jarg2 ? true : false;
69749   {
69750     try {
69751       (arg1)->SetWrapMode(arg2);
69752     } catch (std::out_of_range& e) {
69753       {
69754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69755       };
69756     } catch (std::exception& e) {
69757       {
69758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69759       };
69760     } catch (...) {
69761       {
69762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69763       };
69764     }
69765   }
69766 }
69767
69768
69769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69770   int jresult ;
69771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69772   int result;
69773
69774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69775   {
69776     try {
69777       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69778     } catch (std::out_of_range& e) {
69779       {
69780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69781       };
69782     } catch (std::exception& e) {
69783       {
69784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69785       };
69786     } catch (...) {
69787       {
69788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69789       };
69790     }
69791   }
69792   jresult = result;
69793   return jresult;
69794 }
69795
69796
69797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69799   int arg2 ;
69800
69801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69802   arg2 = (int)jarg2;
69803   {
69804     try {
69805       (arg1)->SetScrollUpdateDistance(arg2);
69806     } catch (std::out_of_range& e) {
69807       {
69808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69809       };
69810     } catch (std::exception& e) {
69811       {
69812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69817       };
69818     }
69819   }
69820 }
69821
69822
69823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69824   unsigned int jresult ;
69825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69826   bool result;
69827
69828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69829   {
69830     try {
69831       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69832     } catch (std::out_of_range& e) {
69833       {
69834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (std::exception& e) {
69837       {
69838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69839       };
69840     } catch (...) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69843       };
69844     }
69845   }
69846   jresult = result;
69847   return jresult;
69848 }
69849
69850
69851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69853   bool arg2 ;
69854
69855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69856   arg2 = jarg2 ? true : false;
69857   {
69858     try {
69859       (arg1)->SetAxisAutoLock(arg2);
69860     } catch (std::out_of_range& e) {
69861       {
69862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69863       };
69864     } catch (std::exception& e) {
69865       {
69866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69867       };
69868     } catch (...) {
69869       {
69870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69871       };
69872     }
69873   }
69874 }
69875
69876
69877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69878   float jresult ;
69879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69880   float result;
69881
69882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69883   {
69884     try {
69885       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69886     } catch (std::out_of_range& e) {
69887       {
69888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69889       };
69890     } catch (std::exception& e) {
69891       {
69892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69893       };
69894     } catch (...) {
69895       {
69896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69897       };
69898     }
69899   }
69900   jresult = result;
69901   return jresult;
69902 }
69903
69904
69905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69907   float arg2 ;
69908
69909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69910   arg2 = (float)jarg2;
69911   {
69912     try {
69913       (arg1)->SetAxisAutoLockGradient(arg2);
69914     } catch (std::out_of_range& e) {
69915       {
69916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69917       };
69918     } catch (std::exception& e) {
69919       {
69920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69921       };
69922     } catch (...) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69925       };
69926     }
69927   }
69928 }
69929
69930
69931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69932   float jresult ;
69933   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69934   float result;
69935
69936   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69937   {
69938     try {
69939       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69940     } catch (std::out_of_range& e) {
69941       {
69942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69943       };
69944     } catch (std::exception& e) {
69945       {
69946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69947       };
69948     } catch (...) {
69949       {
69950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69951       };
69952     }
69953   }
69954   jresult = result;
69955   return jresult;
69956 }
69957
69958
69959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69960   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69961   float arg2 ;
69962
69963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69964   arg2 = (float)jarg2;
69965   {
69966     try {
69967       (arg1)->SetFrictionCoefficient(arg2);
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69975       };
69976     } catch (...) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69979       };
69980     }
69981   }
69982 }
69983
69984
69985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
69986   float jresult ;
69987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69988   float result;
69989
69990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69991   {
69992     try {
69993       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
69994     } catch (std::out_of_range& e) {
69995       {
69996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (std::exception& e) {
69999       {
70000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70005       };
70006     }
70007   }
70008   jresult = result;
70009   return jresult;
70010 }
70011
70012
70013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70015   float arg2 ;
70016
70017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70018   arg2 = (float)jarg2;
70019   {
70020     try {
70021       (arg1)->SetFlickSpeedCoefficient(arg2);
70022     } catch (std::out_of_range& e) {
70023       {
70024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70025       };
70026     } catch (std::exception& e) {
70027       {
70028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70029       };
70030     } catch (...) {
70031       {
70032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70033       };
70034     }
70035   }
70036 }
70037
70038
70039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70040   void * jresult ;
70041   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70042   Dali::Vector2 result;
70043
70044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70045   {
70046     try {
70047       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (...) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70059       };
70060     }
70061   }
70062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70063   return jresult;
70064 }
70065
70066
70067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70069   Dali::Vector2 *arg2 = 0 ;
70070
70071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70072   arg2 = (Dali::Vector2 *)jarg2;
70073   if (!arg2) {
70074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70075     return ;
70076   }
70077   {
70078     try {
70079       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70080     } catch (std::out_of_range& e) {
70081       {
70082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70083       };
70084     } catch (std::exception& e) {
70085       {
70086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70087       };
70088     } catch (...) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70091       };
70092     }
70093   }
70094 }
70095
70096
70097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70098   float jresult ;
70099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70100   float result;
70101
70102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70103   {
70104     try {
70105       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70106     } catch (std::out_of_range& e) {
70107       {
70108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70109       };
70110     } catch (std::exception& e) {
70111       {
70112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (...) {
70115       {
70116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70117       };
70118     }
70119   }
70120   jresult = result;
70121   return jresult;
70122 }
70123
70124
70125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70127   float arg2 ;
70128
70129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70130   arg2 = (float)jarg2;
70131   {
70132     try {
70133       (arg1)->SetMinimumSpeedForFlick(arg2);
70134     } catch (std::out_of_range& e) {
70135       {
70136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70137       };
70138     } catch (std::exception& e) {
70139       {
70140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70141       };
70142     } catch (...) {
70143       {
70144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70145       };
70146     }
70147   }
70148 }
70149
70150
70151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70152   float jresult ;
70153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70154   float result;
70155
70156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70157   {
70158     try {
70159       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70160     } catch (std::out_of_range& e) {
70161       {
70162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70163       };
70164     } catch (std::exception& e) {
70165       {
70166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70167       };
70168     } catch (...) {
70169       {
70170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70171       };
70172     }
70173   }
70174   jresult = result;
70175   return jresult;
70176 }
70177
70178
70179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70181   float arg2 ;
70182
70183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70184   arg2 = (float)jarg2;
70185   {
70186     try {
70187       (arg1)->SetMaxFlickSpeed(arg2);
70188     } catch (std::out_of_range& e) {
70189       {
70190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70191       };
70192     } catch (std::exception& e) {
70193       {
70194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70195       };
70196     } catch (...) {
70197       {
70198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70199       };
70200     }
70201   }
70202 }
70203
70204
70205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70206   void * jresult ;
70207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70208   Dali::Vector2 result;
70209
70210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70211   {
70212     try {
70213       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70214     } catch (std::out_of_range& e) {
70215       {
70216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70217       };
70218     } catch (std::exception& e) {
70219       {
70220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70221       };
70222     } catch (...) {
70223       {
70224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70225       };
70226     }
70227   }
70228   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70229   return jresult;
70230 }
70231
70232
70233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70235   Dali::Vector2 arg2 ;
70236   Dali::Vector2 *argp2 ;
70237
70238   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70239   argp2 = (Dali::Vector2 *)jarg2;
70240   if (!argp2) {
70241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70242     return ;
70243   }
70244   arg2 = *argp2;
70245   {
70246     try {
70247       (arg1)->SetWheelScrollDistanceStep(arg2);
70248     } catch (std::out_of_range& e) {
70249       {
70250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70251       };
70252     } catch (std::exception& e) {
70253       {
70254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70255       };
70256     } catch (...) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70259       };
70260     }
70261   }
70262 }
70263
70264
70265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70266   void * jresult ;
70267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70268   Dali::Vector2 result;
70269
70270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70271   {
70272     try {
70273       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70274     } catch (std::out_of_range& e) {
70275       {
70276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70277       };
70278     } catch (std::exception& e) {
70279       {
70280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (...) {
70283       {
70284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70285       };
70286     }
70287   }
70288   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70289   return jresult;
70290 }
70291
70292
70293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70294   unsigned int jresult ;
70295   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70296   unsigned int result;
70297
70298   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70299   {
70300     try {
70301       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70302     } catch (std::out_of_range& e) {
70303       {
70304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70305       };
70306     } catch (std::exception& e) {
70307       {
70308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (...) {
70311       {
70312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70313       };
70314     }
70315   }
70316   jresult = result;
70317   return jresult;
70318 }
70319
70320
70321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70323   Dali::Vector2 *arg2 = 0 ;
70324
70325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70326   arg2 = (Dali::Vector2 *)jarg2;
70327   if (!arg2) {
70328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70329     return ;
70330   }
70331   {
70332     try {
70333       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70334     } catch (std::out_of_range& e) {
70335       {
70336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70337       };
70338     } catch (std::exception& e) {
70339       {
70340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70341       };
70342     } catch (...) {
70343       {
70344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70345       };
70346     }
70347   }
70348 }
70349
70350
70351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70352   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70353   Dali::Vector2 *arg2 = 0 ;
70354   float arg3 ;
70355
70356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70357   arg2 = (Dali::Vector2 *)jarg2;
70358   if (!arg2) {
70359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70360     return ;
70361   }
70362   arg3 = (float)jarg3;
70363   {
70364     try {
70365       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70366     } catch (std::out_of_range& e) {
70367       {
70368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70369       };
70370     } catch (std::exception& e) {
70371       {
70372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70373       };
70374     } catch (...) {
70375       {
70376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70377       };
70378     }
70379   }
70380 }
70381
70382
70383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70384   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70385   Dali::Vector2 *arg2 = 0 ;
70386   float arg3 ;
70387   Dali::AlphaFunction arg4 ;
70388   Dali::AlphaFunction *argp4 ;
70389
70390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70391   arg2 = (Dali::Vector2 *)jarg2;
70392   if (!arg2) {
70393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70394     return ;
70395   }
70396   arg3 = (float)jarg3;
70397   argp4 = (Dali::AlphaFunction *)jarg4;
70398   if (!argp4) {
70399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70400     return ;
70401   }
70402   arg4 = *argp4;
70403   {
70404     try {
70405       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70406     } catch (std::out_of_range& e) {
70407       {
70408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70409       };
70410     } catch (std::exception& e) {
70411       {
70412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70413       };
70414     } catch (...) {
70415       {
70416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70417       };
70418     }
70419   }
70420 }
70421
70422
70423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70425   Dali::Vector2 *arg2 = 0 ;
70426   float arg3 ;
70427   Dali::Toolkit::DirectionBias arg4 ;
70428   Dali::Toolkit::DirectionBias arg5 ;
70429
70430   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70431   arg2 = (Dali::Vector2 *)jarg2;
70432   if (!arg2) {
70433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70434     return ;
70435   }
70436   arg3 = (float)jarg3;
70437   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70438   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70439   {
70440     try {
70441       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70442     } catch (std::out_of_range& e) {
70443       {
70444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70445       };
70446     } catch (std::exception& e) {
70447       {
70448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70449       };
70450     } catch (...) {
70451       {
70452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70453       };
70454     }
70455   }
70456 }
70457
70458
70459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70461   Dali::Vector2 *arg2 = 0 ;
70462   float arg3 ;
70463   Dali::AlphaFunction arg4 ;
70464   Dali::Toolkit::DirectionBias arg5 ;
70465   Dali::Toolkit::DirectionBias arg6 ;
70466   Dali::AlphaFunction *argp4 ;
70467
70468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70469   arg2 = (Dali::Vector2 *)jarg2;
70470   if (!arg2) {
70471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70472     return ;
70473   }
70474   arg3 = (float)jarg3;
70475   argp4 = (Dali::AlphaFunction *)jarg4;
70476   if (!argp4) {
70477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70478     return ;
70479   }
70480   arg4 = *argp4;
70481   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70482   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70483   {
70484     try {
70485       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70486     } catch (std::out_of_range& e) {
70487       {
70488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70489       };
70490     } catch (std::exception& e) {
70491       {
70492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70493       };
70494     } catch (...) {
70495       {
70496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70497       };
70498     }
70499   }
70500 }
70501
70502
70503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70504   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70505   unsigned int arg2 ;
70506
70507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70508   arg2 = (unsigned int)jarg2;
70509   {
70510     try {
70511       (arg1)->ScrollTo(arg2);
70512     } catch (std::out_of_range& e) {
70513       {
70514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70515       };
70516     } catch (std::exception& e) {
70517       {
70518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70519       };
70520     } catch (...) {
70521       {
70522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70523       };
70524     }
70525   }
70526 }
70527
70528
70529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70531   unsigned int arg2 ;
70532   float arg3 ;
70533
70534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70535   arg2 = (unsigned int)jarg2;
70536   arg3 = (float)jarg3;
70537   {
70538     try {
70539       (arg1)->ScrollTo(arg2,arg3);
70540     } catch (std::out_of_range& e) {
70541       {
70542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70543       };
70544     } catch (std::exception& e) {
70545       {
70546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70547       };
70548     } catch (...) {
70549       {
70550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70551       };
70552     }
70553   }
70554 }
70555
70556
70557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70559   unsigned int arg2 ;
70560   float arg3 ;
70561   Dali::Toolkit::DirectionBias arg4 ;
70562
70563   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70564   arg2 = (unsigned int)jarg2;
70565   arg3 = (float)jarg3;
70566   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70567   {
70568     try {
70569       (arg1)->ScrollTo(arg2,arg3,arg4);
70570     } catch (std::out_of_range& e) {
70571       {
70572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70573       };
70574     } catch (std::exception& e) {
70575       {
70576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70577       };
70578     } catch (...) {
70579       {
70580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70581       };
70582     }
70583   }
70584 }
70585
70586
70587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70589   Dali::Actor *arg2 = 0 ;
70590
70591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70592   arg2 = (Dali::Actor *)jarg2;
70593   if (!arg2) {
70594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70595     return ;
70596   }
70597   {
70598     try {
70599       (arg1)->ScrollTo(*arg2);
70600     } catch (std::out_of_range& e) {
70601       {
70602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70603       };
70604     } catch (std::exception& e) {
70605       {
70606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70607       };
70608     } catch (...) {
70609       {
70610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70611       };
70612     }
70613   }
70614 }
70615
70616
70617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70618   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70619   Dali::Actor *arg2 = 0 ;
70620   float arg3 ;
70621
70622   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70623   arg2 = (Dali::Actor *)jarg2;
70624   if (!arg2) {
70625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70626     return ;
70627   }
70628   arg3 = (float)jarg3;
70629   {
70630     try {
70631       (arg1)->ScrollTo(*arg2,arg3);
70632     } catch (std::out_of_range& e) {
70633       {
70634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70635       };
70636     } catch (std::exception& e) {
70637       {
70638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70639       };
70640     } catch (...) {
70641       {
70642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70643       };
70644     }
70645   }
70646 }
70647
70648
70649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70650   unsigned int jresult ;
70651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70652   bool result;
70653
70654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70655   {
70656     try {
70657       result = (bool)(arg1)->ScrollToSnapPoint();
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (...) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70669       };
70670     }
70671   }
70672   jresult = result;
70673   return jresult;
70674 }
70675
70676
70677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70679   Dali::Constraint arg2 ;
70680   Dali::Constraint *argp2 ;
70681
70682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70683   argp2 = (Dali::Constraint *)jarg2;
70684   if (!argp2) {
70685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70686     return ;
70687   }
70688   arg2 = *argp2;
70689   {
70690     try {
70691       (arg1)->ApplyConstraintToChildren(arg2);
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_RemoveConstraintsFromChildren(void * jarg1) {
70710   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70711
70712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70713   {
70714     try {
70715       (arg1)->RemoveConstraintsFromChildren();
70716     } catch (std::out_of_range& e) {
70717       {
70718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70719       };
70720     } catch (std::exception& e) {
70721       {
70722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70723       };
70724     } catch (...) {
70725       {
70726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70727       };
70728     }
70729   }
70730 }
70731
70732
70733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70735   Dali::Toolkit::ScrollViewEffect arg2 ;
70736   Dali::Toolkit::ScrollViewEffect *argp2 ;
70737
70738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70739   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70740   if (!argp2) {
70741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70742     return ;
70743   }
70744   arg2 = *argp2;
70745   {
70746     try {
70747       (arg1)->ApplyEffect(arg2);
70748     } catch (std::out_of_range& e) {
70749       {
70750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70751       };
70752     } catch (std::exception& e) {
70753       {
70754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70755       };
70756     } catch (...) {
70757       {
70758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70759       };
70760     }
70761   }
70762 }
70763
70764
70765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70766   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70767   Dali::Toolkit::ScrollViewEffect arg2 ;
70768   Dali::Toolkit::ScrollViewEffect *argp2 ;
70769
70770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70771   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70772   if (!argp2) {
70773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70774     return ;
70775   }
70776   arg2 = *argp2;
70777   {
70778     try {
70779       (arg1)->RemoveEffect(arg2);
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_RemoveAllEffects(void * jarg1) {
70798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70799
70800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70801   {
70802     try {
70803       (arg1)->RemoveAllEffects();
70804     } catch (std::out_of_range& e) {
70805       {
70806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (std::exception& e) {
70809       {
70810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70815       };
70816     }
70817   }
70818 }
70819
70820
70821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70823   Dali::Actor arg2 ;
70824   Dali::Actor *argp2 ;
70825
70826   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70827   argp2 = (Dali::Actor *)jarg2;
70828   if (!argp2) {
70829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70830     return ;
70831   }
70832   arg2 = *argp2;
70833   {
70834     try {
70835       (arg1)->BindActor(arg2);
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70843       };
70844     } catch (...) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70847       };
70848     }
70849   }
70850 }
70851
70852
70853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70855   Dali::Actor arg2 ;
70856   Dali::Actor *argp2 ;
70857
70858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70859   argp2 = (Dali::Actor *)jarg2;
70860   if (!argp2) {
70861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70862     return ;
70863   }
70864   arg2 = *argp2;
70865   {
70866     try {
70867       (arg1)->UnbindActor(arg2);
70868     } catch (std::out_of_range& e) {
70869       {
70870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70871       };
70872     } catch (std::exception& e) {
70873       {
70874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70875       };
70876     } catch (...) {
70877       {
70878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70879       };
70880     }
70881   }
70882 }
70883
70884
70885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70886   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70887   Dali::Radian arg2 ;
70888   Dali::Radian arg3 ;
70889   Dali::Radian *argp2 ;
70890   Dali::Radian *argp3 ;
70891
70892   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70893   argp2 = (Dali::Radian *)jarg2;
70894   if (!argp2) {
70895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70896     return ;
70897   }
70898   arg2 = *argp2;
70899   argp3 = (Dali::Radian *)jarg3;
70900   if (!argp3) {
70901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70902     return ;
70903   }
70904   arg3 = *argp3;
70905   {
70906     try {
70907       (arg1)->SetScrollingDirection(arg2,arg3);
70908     } catch (std::out_of_range& e) {
70909       {
70910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70911       };
70912     } catch (std::exception& e) {
70913       {
70914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70915       };
70916     } catch (...) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70919       };
70920     }
70921   }
70922 }
70923
70924
70925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70927   Dali::Radian arg2 ;
70928   Dali::Radian *argp2 ;
70929
70930   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70931   argp2 = (Dali::Radian *)jarg2;
70932   if (!argp2) {
70933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70934     return ;
70935   }
70936   arg2 = *argp2;
70937   {
70938     try {
70939       (arg1)->SetScrollingDirection(arg2);
70940     } catch (std::out_of_range& e) {
70941       {
70942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70943       };
70944     } catch (std::exception& e) {
70945       {
70946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70947       };
70948     } catch (...) {
70949       {
70950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70951       };
70952     }
70953   }
70954 }
70955
70956
70957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70958   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70959   Dali::Radian arg2 ;
70960   Dali::Radian *argp2 ;
70961
70962   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70963   argp2 = (Dali::Radian *)jarg2;
70964   if (!argp2) {
70965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70966     return ;
70967   }
70968   arg2 = *argp2;
70969   {
70970     try {
70971       (arg1)->RemoveScrollingDirection(arg2);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70983       };
70984     }
70985   }
70986 }
70987
70988
70989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
70990   void * jresult ;
70991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70992   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
70993
70994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70995   {
70996     try {
70997       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
70998     } catch (std::out_of_range& e) {
70999       {
71000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71001       };
71002     } catch (std::exception& e) {
71003       {
71004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71005       };
71006     } catch (...) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71009       };
71010     }
71011   }
71012   jresult = (void *)result;
71013   return jresult;
71014 }
71015
71016
71017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71018   int jresult ;
71019   int result;
71020
71021   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71022   jresult = (int)result;
71023   return jresult;
71024 }
71025
71026
71027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71028   int jresult ;
71029   int result;
71030
71031   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71032   jresult = (int)result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71038   int jresult ;
71039   int result;
71040
71041   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71042   jresult = (int)result;
71043   return jresult;
71044 }
71045
71046
71047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71048   int jresult ;
71049   int result;
71050
71051   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71052   jresult = (int)result;
71053   return jresult;
71054 }
71055
71056
71057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71058   int jresult ;
71059   int result;
71060
71061   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71062   jresult = (int)result;
71063   return jresult;
71064 }
71065
71066
71067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71068   void * jresult ;
71069   Dali::Toolkit::TableView::Property *result = 0 ;
71070
71071   {
71072     try {
71073       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71074     } catch (std::out_of_range& e) {
71075       {
71076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71077       };
71078     } catch (std::exception& e) {
71079       {
71080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71081       };
71082     } catch (...) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71085       };
71086     }
71087   }
71088   jresult = (void *)result;
71089   return jresult;
71090 }
71091
71092
71093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71094   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71095
71096   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71097   {
71098     try {
71099       delete arg1;
71100     } catch (std::out_of_range& e) {
71101       {
71102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71103       };
71104     } catch (std::exception& e) {
71105       {
71106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (...) {
71109       {
71110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71111       };
71112     }
71113   }
71114 }
71115
71116
71117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71118   int jresult ;
71119   int result;
71120
71121   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71122   jresult = (int)result;
71123   return jresult;
71124 }
71125
71126
71127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71128   int jresult ;
71129   int result;
71130
71131   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71132   jresult = (int)result;
71133   return jresult;
71134 }
71135
71136
71137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71138   int jresult ;
71139   int result;
71140
71141   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71142   jresult = (int)result;
71143   return jresult;
71144 }
71145
71146
71147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71148   int jresult ;
71149   int result;
71150
71151   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71152   jresult = (int)result;
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71158   int jresult ;
71159   int result;
71160
71161   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71162   jresult = (int)result;
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71168   void * jresult ;
71169   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71170
71171   {
71172     try {
71173       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71174     } catch (std::out_of_range& e) {
71175       {
71176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71177       };
71178     } catch (std::exception& e) {
71179       {
71180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71185       };
71186     }
71187   }
71188   jresult = (void *)result;
71189   return jresult;
71190 }
71191
71192
71193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71194   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71195
71196   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71197   {
71198     try {
71199       delete arg1;
71200     } catch (std::out_of_range& e) {
71201       {
71202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71203       };
71204     } catch (std::exception& e) {
71205       {
71206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71211       };
71212     }
71213   }
71214 }
71215
71216
71217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71218   void * jresult ;
71219   unsigned int arg1 ;
71220   unsigned int arg2 ;
71221   unsigned int arg3 ;
71222   unsigned int arg4 ;
71223   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71224
71225   arg1 = (unsigned int)jarg1;
71226   arg2 = (unsigned int)jarg2;
71227   arg3 = (unsigned int)jarg3;
71228   arg4 = (unsigned int)jarg4;
71229   {
71230     try {
71231       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71232     } catch (std::out_of_range& e) {
71233       {
71234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71235       };
71236     } catch (std::exception& e) {
71237       {
71238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71239       };
71240     } catch (...) {
71241       {
71242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71243       };
71244     }
71245   }
71246   jresult = (void *)result;
71247   return jresult;
71248 }
71249
71250
71251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71252   void * jresult ;
71253   unsigned int arg1 ;
71254   unsigned int arg2 ;
71255   unsigned int arg3 ;
71256   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71257
71258   arg1 = (unsigned int)jarg1;
71259   arg2 = (unsigned int)jarg2;
71260   arg3 = (unsigned int)jarg3;
71261   {
71262     try {
71263       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71264     } catch (std::out_of_range& e) {
71265       {
71266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71267       };
71268     } catch (std::exception& e) {
71269       {
71270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71271       };
71272     } catch (...) {
71273       {
71274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71275       };
71276     }
71277   }
71278   jresult = (void *)result;
71279   return jresult;
71280 }
71281
71282
71283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71284   void * jresult ;
71285   unsigned int arg1 ;
71286   unsigned int arg2 ;
71287   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71288
71289   arg1 = (unsigned int)jarg1;
71290   arg2 = (unsigned int)jarg2;
71291   {
71292     try {
71293       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71294     } catch (std::out_of_range& e) {
71295       {
71296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71297       };
71298     } catch (std::exception& e) {
71299       {
71300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71301       };
71302     } catch (...) {
71303       {
71304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71305       };
71306     }
71307   }
71308   jresult = (void *)result;
71309   return jresult;
71310 }
71311
71312
71313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71314   void * jresult ;
71315   unsigned int arg1 ;
71316   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71317
71318   arg1 = (unsigned int)jarg1;
71319   {
71320     try {
71321       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71322     } catch (std::out_of_range& e) {
71323       {
71324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71325       };
71326     } catch (std::exception& e) {
71327       {
71328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71329       };
71330     } catch (...) {
71331       {
71332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71333       };
71334     }
71335   }
71336   jresult = (void *)result;
71337   return jresult;
71338 }
71339
71340
71341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71342   void * jresult ;
71343   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71344
71345   {
71346     try {
71347       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71348     } catch (std::out_of_range& e) {
71349       {
71350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71351       };
71352     } catch (std::exception& e) {
71353       {
71354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71355       };
71356     } catch (...) {
71357       {
71358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71359       };
71360     }
71361   }
71362   jresult = (void *)result;
71363   return jresult;
71364 }
71365
71366
71367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71368   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71369   unsigned int arg2 ;
71370
71371   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71372   arg2 = (unsigned int)jarg2;
71373   if (arg1) (arg1)->rowIndex = arg2;
71374 }
71375
71376
71377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71378   unsigned int jresult ;
71379   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71380   unsigned int result;
71381
71382   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71383   result = (unsigned int) ((arg1)->rowIndex);
71384   jresult = result;
71385   return jresult;
71386 }
71387
71388
71389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71390   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71391   unsigned int arg2 ;
71392
71393   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71394   arg2 = (unsigned int)jarg2;
71395   if (arg1) (arg1)->columnIndex = arg2;
71396 }
71397
71398
71399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71400   unsigned int jresult ;
71401   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71402   unsigned int result;
71403
71404   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71405   result = (unsigned int) ((arg1)->columnIndex);
71406   jresult = result;
71407   return jresult;
71408 }
71409
71410
71411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71412   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71413   unsigned int arg2 ;
71414
71415   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71416   arg2 = (unsigned int)jarg2;
71417   if (arg1) (arg1)->rowSpan = arg2;
71418 }
71419
71420
71421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71422   unsigned int jresult ;
71423   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71424   unsigned int result;
71425
71426   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71427   result = (unsigned int) ((arg1)->rowSpan);
71428   jresult = result;
71429   return jresult;
71430 }
71431
71432
71433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71434   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71435   unsigned int arg2 ;
71436
71437   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71438   arg2 = (unsigned int)jarg2;
71439   if (arg1) (arg1)->columnSpan = arg2;
71440 }
71441
71442
71443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71444   unsigned int jresult ;
71445   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71446   unsigned int result;
71447
71448   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71449   result = (unsigned int) ((arg1)->columnSpan);
71450   jresult = result;
71451   return jresult;
71452 }
71453
71454
71455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71456   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71457
71458   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71459   {
71460     try {
71461       delete arg1;
71462     } catch (std::out_of_range& e) {
71463       {
71464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71465       };
71466     } catch (std::exception& e) {
71467       {
71468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71469       };
71470     } catch (...) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71473       };
71474     }
71475   }
71476 }
71477
71478
71479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71480   void * jresult ;
71481   Dali::Toolkit::TableView *result = 0 ;
71482
71483   {
71484     try {
71485       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71486     } catch (std::out_of_range& e) {
71487       {
71488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71489       };
71490     } catch (std::exception& e) {
71491       {
71492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (...) {
71495       {
71496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71497       };
71498     }
71499   }
71500   jresult = (void *)result;
71501   return jresult;
71502 }
71503
71504
71505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71506   void * jresult ;
71507   Dali::Toolkit::TableView *arg1 = 0 ;
71508   Dali::Toolkit::TableView *result = 0 ;
71509
71510   arg1 = (Dali::Toolkit::TableView *)jarg1;
71511   if (!arg1) {
71512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71513     return 0;
71514   }
71515   {
71516     try {
71517       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71518     } catch (std::out_of_range& e) {
71519       {
71520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71521       };
71522     } catch (std::exception& e) {
71523       {
71524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71525       };
71526     } catch (...) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71529       };
71530     }
71531   }
71532   jresult = (void *)result;
71533   return jresult;
71534 }
71535
71536
71537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71538   void * jresult ;
71539   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71540   Dali::Toolkit::TableView *arg2 = 0 ;
71541   Dali::Toolkit::TableView *result = 0 ;
71542
71543   arg1 = (Dali::Toolkit::TableView *)jarg1;
71544   arg2 = (Dali::Toolkit::TableView *)jarg2;
71545   if (!arg2) {
71546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71547     return 0;
71548   }
71549   {
71550     try {
71551       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71552     } catch (std::out_of_range& e) {
71553       {
71554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71555       };
71556     } catch (std::exception& e) {
71557       {
71558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71559       };
71560     } catch (...) {
71561       {
71562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71563       };
71564     }
71565   }
71566   jresult = (void *)result;
71567   return jresult;
71568 }
71569
71570
71571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71572   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71573
71574   arg1 = (Dali::Toolkit::TableView *)jarg1;
71575   {
71576     try {
71577       delete arg1;
71578     } catch (std::out_of_range& e) {
71579       {
71580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71581       };
71582     } catch (std::exception& e) {
71583       {
71584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71585       };
71586     } catch (...) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71589       };
71590     }
71591   }
71592 }
71593
71594
71595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71596   void * jresult ;
71597   unsigned int arg1 ;
71598   unsigned int arg2 ;
71599   Dali::Toolkit::TableView result;
71600
71601   arg1 = (unsigned int)jarg1;
71602   arg2 = (unsigned int)jarg2;
71603   {
71604     try {
71605       result = Dali::Toolkit::TableView::New(arg1,arg2);
71606     } catch (std::out_of_range& e) {
71607       {
71608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71609       };
71610     } catch (std::exception& e) {
71611       {
71612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71613       };
71614     } catch (...) {
71615       {
71616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71617       };
71618     }
71619   }
71620   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71621   return jresult;
71622 }
71623
71624
71625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71626   void * jresult ;
71627   Dali::BaseHandle arg1 ;
71628   Dali::BaseHandle *argp1 ;
71629   Dali::Toolkit::TableView result;
71630
71631   argp1 = (Dali::BaseHandle *)jarg1;
71632   if (!argp1) {
71633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71634     return 0;
71635   }
71636   arg1 = *argp1;
71637   {
71638     try {
71639       result = Dali::Toolkit::TableView::DownCast(arg1);
71640     } catch (std::out_of_range& e) {
71641       {
71642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71643       };
71644     } catch (std::exception& e) {
71645       {
71646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71647       };
71648     } catch (...) {
71649       {
71650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71651       };
71652     }
71653   }
71654   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71655   return jresult;
71656 }
71657
71658
71659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71660   unsigned int jresult ;
71661   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71662   Dali::Actor arg2 ;
71663   Dali::Toolkit::TableView::CellPosition arg3 ;
71664   Dali::Actor *argp2 ;
71665   Dali::Toolkit::TableView::CellPosition *argp3 ;
71666   bool result;
71667
71668   arg1 = (Dali::Toolkit::TableView *)jarg1;
71669   argp2 = (Dali::Actor *)jarg2;
71670   if (!argp2) {
71671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71672     return 0;
71673   }
71674   arg2 = *argp2;
71675   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71676   if (!argp3) {
71677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71678     return 0;
71679   }
71680   arg3 = *argp3;
71681   {
71682     try {
71683       result = (bool)(arg1)->AddChild(arg2,arg3);
71684     } catch (std::out_of_range& e) {
71685       {
71686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71687       };
71688     } catch (std::exception& e) {
71689       {
71690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71691       };
71692     } catch (...) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71695       };
71696     }
71697   }
71698   jresult = result;
71699   return jresult;
71700 }
71701
71702
71703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71704   void * jresult ;
71705   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71706   Dali::Toolkit::TableView::CellPosition arg2 ;
71707   Dali::Toolkit::TableView::CellPosition *argp2 ;
71708   Dali::Actor result;
71709
71710   arg1 = (Dali::Toolkit::TableView *)jarg1;
71711   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71712   if (!argp2) {
71713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71714     return 0;
71715   }
71716   arg2 = *argp2;
71717   {
71718     try {
71719       result = (arg1)->GetChildAt(arg2);
71720     } catch (std::out_of_range& e) {
71721       {
71722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71723       };
71724     } catch (std::exception& e) {
71725       {
71726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71727       };
71728     } catch (...) {
71729       {
71730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71731       };
71732     }
71733   }
71734   jresult = new Dali::Actor((const Dali::Actor &)result);
71735   return jresult;
71736 }
71737
71738
71739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71740   void * jresult ;
71741   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71742   Dali::Toolkit::TableView::CellPosition arg2 ;
71743   Dali::Toolkit::TableView::CellPosition *argp2 ;
71744   Dali::Actor result;
71745
71746   arg1 = (Dali::Toolkit::TableView *)jarg1;
71747   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71748   if (!argp2) {
71749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71750     return 0;
71751   }
71752   arg2 = *argp2;
71753   {
71754     try {
71755       result = (arg1)->RemoveChildAt(arg2);
71756     } catch (std::out_of_range& e) {
71757       {
71758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71759       };
71760     } catch (std::exception& e) {
71761       {
71762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71763       };
71764     } catch (...) {
71765       {
71766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71767       };
71768     }
71769   }
71770   jresult = new Dali::Actor((const Dali::Actor &)result);
71771   return jresult;
71772 }
71773
71774
71775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71776   unsigned int jresult ;
71777   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71778   Dali::Actor arg2 ;
71779   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71780   Dali::Actor *argp2 ;
71781   bool result;
71782
71783   arg1 = (Dali::Toolkit::TableView *)jarg1;
71784   argp2 = (Dali::Actor *)jarg2;
71785   if (!argp2) {
71786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71787     return 0;
71788   }
71789   arg2 = *argp2;
71790   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71791   if (!arg3) {
71792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71793     return 0;
71794   }
71795   {
71796     try {
71797       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71798     } catch (std::out_of_range& e) {
71799       {
71800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71801       };
71802     } catch (std::exception& e) {
71803       {
71804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71805       };
71806     } catch (...) {
71807       {
71808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71809       };
71810     }
71811   }
71812   jresult = result;
71813   return jresult;
71814 }
71815
71816
71817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71818   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71819   unsigned int arg2 ;
71820
71821   arg1 = (Dali::Toolkit::TableView *)jarg1;
71822   arg2 = (unsigned int)jarg2;
71823   {
71824     try {
71825       (arg1)->InsertRow(arg2);
71826     } catch (std::out_of_range& e) {
71827       {
71828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71829       };
71830     } catch (std::exception& e) {
71831       {
71832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71833       };
71834     } catch (...) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71837       };
71838     }
71839   }
71840 }
71841
71842
71843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71844   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71845   unsigned int arg2 ;
71846
71847   arg1 = (Dali::Toolkit::TableView *)jarg1;
71848   arg2 = (unsigned int)jarg2;
71849   {
71850     try {
71851       (arg1)->DeleteRow(arg2);
71852     } catch (std::out_of_range& e) {
71853       {
71854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71855       };
71856     } catch (std::exception& e) {
71857       {
71858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71859       };
71860     } catch (...) {
71861       {
71862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71863       };
71864     }
71865   }
71866 }
71867
71868
71869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71870   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71871   unsigned int arg2 ;
71872   std::vector< Dali::Actor > *arg3 = 0 ;
71873
71874   arg1 = (Dali::Toolkit::TableView *)jarg1;
71875   arg2 = (unsigned int)jarg2;
71876   arg3 = (std::vector< Dali::Actor > *)jarg3;
71877   if (!arg3) {
71878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71879     return ;
71880   }
71881   {
71882     try {
71883       (arg1)->DeleteRow(arg2,*arg3);
71884     } catch (std::out_of_range& e) {
71885       {
71886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71887       };
71888     } catch (std::exception& e) {
71889       {
71890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71891       };
71892     } catch (...) {
71893       {
71894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71895       };
71896     }
71897   }
71898 }
71899
71900
71901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71902   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71903   unsigned int arg2 ;
71904
71905   arg1 = (Dali::Toolkit::TableView *)jarg1;
71906   arg2 = (unsigned int)jarg2;
71907   {
71908     try {
71909       (arg1)->InsertColumn(arg2);
71910     } catch (std::out_of_range& e) {
71911       {
71912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71913       };
71914     } catch (std::exception& e) {
71915       {
71916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71917       };
71918     } catch (...) {
71919       {
71920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71921       };
71922     }
71923   }
71924 }
71925
71926
71927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71928   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71929   unsigned int arg2 ;
71930
71931   arg1 = (Dali::Toolkit::TableView *)jarg1;
71932   arg2 = (unsigned int)jarg2;
71933   {
71934     try {
71935       (arg1)->DeleteColumn(arg2);
71936     } catch (std::out_of_range& e) {
71937       {
71938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71939       };
71940     } catch (std::exception& e) {
71941       {
71942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71943       };
71944     } catch (...) {
71945       {
71946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71947       };
71948     }
71949   }
71950 }
71951
71952
71953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71954   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71955   unsigned int arg2 ;
71956   std::vector< Dali::Actor > *arg3 = 0 ;
71957
71958   arg1 = (Dali::Toolkit::TableView *)jarg1;
71959   arg2 = (unsigned int)jarg2;
71960   arg3 = (std::vector< Dali::Actor > *)jarg3;
71961   if (!arg3) {
71962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71963     return ;
71964   }
71965   {
71966     try {
71967       (arg1)->DeleteColumn(arg2,*arg3);
71968     } catch (std::out_of_range& e) {
71969       {
71970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71971       };
71972     } catch (std::exception& e) {
71973       {
71974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71975       };
71976     } catch (...) {
71977       {
71978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71979       };
71980     }
71981   }
71982 }
71983
71984
71985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
71986   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71987   unsigned int arg2 ;
71988   unsigned int arg3 ;
71989
71990   arg1 = (Dali::Toolkit::TableView *)jarg1;
71991   arg2 = (unsigned int)jarg2;
71992   arg3 = (unsigned int)jarg3;
71993   {
71994     try {
71995       (arg1)->Resize(arg2,arg3);
71996     } catch (std::out_of_range& e) {
71997       {
71998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71999       };
72000     } catch (std::exception& e) {
72001       {
72002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72003       };
72004     } catch (...) {
72005       {
72006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72007       };
72008     }
72009   }
72010 }
72011
72012
72013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72015   unsigned int arg2 ;
72016   unsigned int arg3 ;
72017   std::vector< Dali::Actor > *arg4 = 0 ;
72018
72019   arg1 = (Dali::Toolkit::TableView *)jarg1;
72020   arg2 = (unsigned int)jarg2;
72021   arg3 = (unsigned int)jarg3;
72022   arg4 = (std::vector< Dali::Actor > *)jarg4;
72023   if (!arg4) {
72024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72025     return ;
72026   }
72027   {
72028     try {
72029       (arg1)->Resize(arg2,arg3,*arg4);
72030     } catch (std::out_of_range& e) {
72031       {
72032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72033       };
72034     } catch (std::exception& e) {
72035       {
72036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72037       };
72038     } catch (...) {
72039       {
72040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72041       };
72042     }
72043   }
72044 }
72045
72046
72047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72049   Dali::Size arg2 ;
72050   Dali::Size *argp2 ;
72051
72052   arg1 = (Dali::Toolkit::TableView *)jarg1;
72053   argp2 = (Dali::Size *)jarg2;
72054   if (!argp2) {
72055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72056     return ;
72057   }
72058   arg2 = *argp2;
72059   {
72060     try {
72061       (arg1)->SetCellPadding(arg2);
72062     } catch (std::out_of_range& e) {
72063       {
72064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72065       };
72066     } catch (std::exception& e) {
72067       {
72068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72069       };
72070     } catch (...) {
72071       {
72072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72073       };
72074     }
72075   }
72076 }
72077
72078
72079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72080   void * jresult ;
72081   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72082   Dali::Size result;
72083
72084   arg1 = (Dali::Toolkit::TableView *)jarg1;
72085   {
72086     try {
72087       result = (arg1)->GetCellPadding();
72088     } catch (std::out_of_range& e) {
72089       {
72090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72091       };
72092     } catch (std::exception& e) {
72093       {
72094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72095       };
72096     } catch (...) {
72097       {
72098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72099       };
72100     }
72101   }
72102   jresult = new Dali::Size((const Dali::Size &)result);
72103   return jresult;
72104 }
72105
72106
72107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72108   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72109   unsigned int arg2 ;
72110
72111   arg1 = (Dali::Toolkit::TableView *)jarg1;
72112   arg2 = (unsigned int)jarg2;
72113   {
72114     try {
72115       (arg1)->SetFitHeight(arg2);
72116     } catch (std::out_of_range& e) {
72117       {
72118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72119       };
72120     } catch (std::exception& e) {
72121       {
72122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72123       };
72124     } catch (...) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72127       };
72128     }
72129   }
72130 }
72131
72132
72133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72134   unsigned int jresult ;
72135   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72136   unsigned int arg2 ;
72137   bool result;
72138
72139   arg1 = (Dali::Toolkit::TableView *)jarg1;
72140   arg2 = (unsigned int)jarg2;
72141   {
72142     try {
72143       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72144     } catch (std::out_of_range& e) {
72145       {
72146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72147       };
72148     } catch (std::exception& e) {
72149       {
72150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72151       };
72152     } catch (...) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72155       };
72156     }
72157   }
72158   jresult = result;
72159   return jresult;
72160 }
72161
72162
72163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72164   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72165   unsigned int arg2 ;
72166
72167   arg1 = (Dali::Toolkit::TableView *)jarg1;
72168   arg2 = (unsigned int)jarg2;
72169   {
72170     try {
72171       (arg1)->SetFitWidth(arg2);
72172     } catch (std::out_of_range& e) {
72173       {
72174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72175       };
72176     } catch (std::exception& e) {
72177       {
72178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72183       };
72184     }
72185   }
72186 }
72187
72188
72189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72190   unsigned int jresult ;
72191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72192   unsigned int arg2 ;
72193   bool result;
72194
72195   arg1 = (Dali::Toolkit::TableView *)jarg1;
72196   arg2 = (unsigned int)jarg2;
72197   {
72198     try {
72199       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72200     } catch (std::out_of_range& e) {
72201       {
72202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72203       };
72204     } catch (std::exception& e) {
72205       {
72206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72207       };
72208     } catch (...) {
72209       {
72210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72211       };
72212     }
72213   }
72214   jresult = result;
72215   return jresult;
72216 }
72217
72218
72219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72220   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72221   unsigned int arg2 ;
72222   float arg3 ;
72223
72224   arg1 = (Dali::Toolkit::TableView *)jarg1;
72225   arg2 = (unsigned int)jarg2;
72226   arg3 = (float)jarg3;
72227   {
72228     try {
72229       (arg1)->SetFixedHeight(arg2,arg3);
72230     } catch (std::out_of_range& e) {
72231       {
72232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72233       };
72234     } catch (std::exception& e) {
72235       {
72236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72237       };
72238     } catch (...) {
72239       {
72240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72241       };
72242     }
72243   }
72244 }
72245
72246
72247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72248   float jresult ;
72249   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72250   unsigned int arg2 ;
72251   float result;
72252
72253   arg1 = (Dali::Toolkit::TableView *)jarg1;
72254   arg2 = (unsigned int)jarg2;
72255   {
72256     try {
72257       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72258     } catch (std::out_of_range& e) {
72259       {
72260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72261       };
72262     } catch (std::exception& e) {
72263       {
72264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72265       };
72266     } catch (...) {
72267       {
72268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72269       };
72270     }
72271   }
72272   jresult = result;
72273   return jresult;
72274 }
72275
72276
72277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72279   unsigned int arg2 ;
72280   float arg3 ;
72281
72282   arg1 = (Dali::Toolkit::TableView *)jarg1;
72283   arg2 = (unsigned int)jarg2;
72284   arg3 = (float)jarg3;
72285   {
72286     try {
72287       (arg1)->SetRelativeHeight(arg2,arg3);
72288     } catch (std::out_of_range& e) {
72289       {
72290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72291       };
72292     } catch (std::exception& e) {
72293       {
72294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72295       };
72296     } catch (...) {
72297       {
72298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72299       };
72300     }
72301   }
72302 }
72303
72304
72305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72306   float jresult ;
72307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72308   unsigned int arg2 ;
72309   float result;
72310
72311   arg1 = (Dali::Toolkit::TableView *)jarg1;
72312   arg2 = (unsigned int)jarg2;
72313   {
72314     try {
72315       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72316     } catch (std::out_of_range& e) {
72317       {
72318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72319       };
72320     } catch (std::exception& e) {
72321       {
72322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72323       };
72324     } catch (...) {
72325       {
72326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72327       };
72328     }
72329   }
72330   jresult = result;
72331   return jresult;
72332 }
72333
72334
72335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72337   unsigned int arg2 ;
72338   float arg3 ;
72339
72340   arg1 = (Dali::Toolkit::TableView *)jarg1;
72341   arg2 = (unsigned int)jarg2;
72342   arg3 = (float)jarg3;
72343   {
72344     try {
72345       (arg1)->SetFixedWidth(arg2,arg3);
72346     } catch (std::out_of_range& e) {
72347       {
72348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72349       };
72350     } catch (std::exception& e) {
72351       {
72352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72353       };
72354     } catch (...) {
72355       {
72356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72357       };
72358     }
72359   }
72360 }
72361
72362
72363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72364   float jresult ;
72365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72366   unsigned int arg2 ;
72367   float result;
72368
72369   arg1 = (Dali::Toolkit::TableView *)jarg1;
72370   arg2 = (unsigned int)jarg2;
72371   {
72372     try {
72373       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72374     } catch (std::out_of_range& e) {
72375       {
72376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72377       };
72378     } catch (std::exception& e) {
72379       {
72380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72381       };
72382     } catch (...) {
72383       {
72384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72385       };
72386     }
72387   }
72388   jresult = result;
72389   return jresult;
72390 }
72391
72392
72393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72395   unsigned int arg2 ;
72396   float arg3 ;
72397
72398   arg1 = (Dali::Toolkit::TableView *)jarg1;
72399   arg2 = (unsigned int)jarg2;
72400   arg3 = (float)jarg3;
72401   {
72402     try {
72403       (arg1)->SetRelativeWidth(arg2,arg3);
72404     } catch (std::out_of_range& e) {
72405       {
72406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72407       };
72408     } catch (std::exception& e) {
72409       {
72410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72411       };
72412     } catch (...) {
72413       {
72414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72415       };
72416     }
72417   }
72418 }
72419
72420
72421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72422   float jresult ;
72423   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72424   unsigned int arg2 ;
72425   float result;
72426
72427   arg1 = (Dali::Toolkit::TableView *)jarg1;
72428   arg2 = (unsigned int)jarg2;
72429   {
72430     try {
72431       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72432     } catch (std::out_of_range& e) {
72433       {
72434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72435       };
72436     } catch (std::exception& e) {
72437       {
72438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72439       };
72440     } catch (...) {
72441       {
72442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72443       };
72444     }
72445   }
72446   jresult = result;
72447   return jresult;
72448 }
72449
72450
72451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72452   unsigned int jresult ;
72453   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72454   unsigned int result;
72455
72456   arg1 = (Dali::Toolkit::TableView *)jarg1;
72457   {
72458     try {
72459       result = (unsigned int)(arg1)->GetRows();
72460     } catch (std::out_of_range& e) {
72461       {
72462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72463       };
72464     } catch (std::exception& e) {
72465       {
72466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72467       };
72468     } catch (...) {
72469       {
72470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72471       };
72472     }
72473   }
72474   jresult = result;
72475   return jresult;
72476 }
72477
72478
72479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72480   unsigned int jresult ;
72481   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72482   unsigned int result;
72483
72484   arg1 = (Dali::Toolkit::TableView *)jarg1;
72485   {
72486     try {
72487       result = (unsigned int)(arg1)->GetColumns();
72488     } catch (std::out_of_range& e) {
72489       {
72490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72491       };
72492     } catch (std::exception& e) {
72493       {
72494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72495       };
72496     } catch (...) {
72497       {
72498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72499       };
72500     }
72501   }
72502   jresult = result;
72503   return jresult;
72504 }
72505
72506
72507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72508   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72509   Dali::Toolkit::TableView::CellPosition arg2 ;
72510   Dali::HorizontalAlignment::Type arg3 ;
72511   Dali::VerticalAlignment::Type arg4 ;
72512   Dali::Toolkit::TableView::CellPosition *argp2 ;
72513
72514   arg1 = (Dali::Toolkit::TableView *)jarg1;
72515   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72516   if (!argp2) {
72517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72518     return ;
72519   }
72520   arg2 = *argp2;
72521   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72522   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72523   {
72524     try {
72525       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72526     } catch (std::out_of_range& e) {
72527       {
72528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72529       };
72530     } catch (std::exception& e) {
72531       {
72532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72533       };
72534     } catch (...) {
72535       {
72536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72537       };
72538     }
72539   }
72540 }
72541
72542
72543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72544   unsigned int jresult ;
72545   unsigned int result;
72546
72547   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72548   jresult = result;
72549   return jresult;
72550 }
72551
72552
72553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72554   int jresult ;
72555   int result;
72556
72557   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72558   jresult = (int)result;
72559   return jresult;
72560 }
72561
72562
72563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72564   int jresult ;
72565   int result;
72566
72567   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72568   jresult = (int)result;
72569   return jresult;
72570 }
72571
72572
72573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72574   int jresult ;
72575   int result;
72576
72577   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72578   jresult = (int)result;
72579   return jresult;
72580 }
72581
72582
72583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72584   int jresult ;
72585   int result;
72586
72587   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72588   jresult = (int)result;
72589   return jresult;
72590 }
72591
72592
72593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72594   int jresult ;
72595   int result;
72596
72597   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72598   jresult = (int)result;
72599   return jresult;
72600 }
72601
72602
72603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72604   int jresult ;
72605   int result;
72606
72607   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72608   jresult = (int)result;
72609   return jresult;
72610 }
72611
72612
72613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72614   int jresult ;
72615   int result;
72616
72617   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72618   jresult = (int)result;
72619   return jresult;
72620 }
72621
72622
72623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72624   int jresult ;
72625   int result;
72626
72627   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72628   jresult = (int)result;
72629   return jresult;
72630 }
72631
72632
72633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72634   int jresult ;
72635   int result;
72636
72637   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72638   jresult = (int)result;
72639   return jresult;
72640 }
72641
72642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
72643   int jresult ;
72644   int result;
72645
72646   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
72647   jresult = (int)result;
72648   return jresult;
72649 }
72650
72651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72652   int jresult ;
72653   int result;
72654
72655   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72656   jresult = (int)result;
72657   return jresult;
72658 }
72659
72660
72661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72662   int jresult ;
72663   int result;
72664
72665   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72666   jresult = (int)result;
72667   return jresult;
72668 }
72669
72670
72671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72672   int jresult ;
72673   int result;
72674
72675   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72676   jresult = (int)result;
72677   return jresult;
72678 }
72679
72680
72681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72682   int jresult ;
72683   int result;
72684
72685   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72686   jresult = (int)result;
72687   return jresult;
72688 }
72689
72690
72691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72692   int jresult ;
72693   int result;
72694
72695   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72696   jresult = (int)result;
72697   return jresult;
72698 }
72699
72700
72701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72702   int jresult ;
72703   int result;
72704
72705   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72706   jresult = (int)result;
72707   return jresult;
72708 }
72709
72710
72711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72712   int jresult ;
72713   int result;
72714
72715   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72716   jresult = (int)result;
72717   return jresult;
72718 }
72719
72720
72721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72722   int jresult ;
72723   int result;
72724
72725   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72726   jresult = (int)result;
72727   return jresult;
72728 }
72729
72730
72731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72732   int jresult ;
72733   int result;
72734
72735   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72736   jresult = (int)result;
72737   return jresult;
72738 }
72739
72740
72741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72742   int jresult ;
72743   int result;
72744
72745   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72746   jresult = (int)result;
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72752   int jresult ;
72753   int result;
72754
72755   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72756   jresult = (int)result;
72757   return jresult;
72758 }
72759
72760
72761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72762   int jresult ;
72763   int result;
72764
72765   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72766   jresult = (int)result;
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72772   int jresult ;
72773   int result;
72774
72775   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72776   jresult = (int)result;
72777   return jresult;
72778 }
72779
72780
72781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72782   int jresult ;
72783   int result;
72784
72785   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72786   jresult = (int)result;
72787   return jresult;
72788 }
72789
72790
72791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72792   int jresult ;
72793   int result;
72794
72795   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72796   jresult = (int)result;
72797   return jresult;
72798 }
72799
72800
72801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72802   void * jresult ;
72803   Dali::Toolkit::TextLabel::Property *result = 0 ;
72804
72805   {
72806     try {
72807       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72808     } catch (std::out_of_range& e) {
72809       {
72810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72811       };
72812     } catch (std::exception& e) {
72813       {
72814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72815       };
72816     } catch (...) {
72817       {
72818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72819       };
72820     }
72821   }
72822   jresult = (void *)result;
72823   return jresult;
72824 }
72825
72826
72827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72828   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72829
72830   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72831   {
72832     try {
72833       delete arg1;
72834     } catch (std::out_of_range& e) {
72835       {
72836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72837       };
72838     } catch (std::exception& e) {
72839       {
72840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72841       };
72842     } catch (...) {
72843       {
72844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72845       };
72846     }
72847   }
72848 }
72849
72850
72851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72852   void * jresult ;
72853   Dali::Toolkit::TextLabel result;
72854
72855   {
72856     try {
72857       result = Dali::Toolkit::TextLabel::New();
72858     } catch (std::out_of_range& e) {
72859       {
72860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72861       };
72862     } catch (std::exception& e) {
72863       {
72864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72865       };
72866     } catch (...) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72869       };
72870     }
72871   }
72872   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72873   return jresult;
72874 }
72875
72876
72877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72878   void * jresult ;
72879   std::string *arg1 = 0 ;
72880   Dali::Toolkit::TextLabel result;
72881
72882   if (!jarg1) {
72883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72884     return 0;
72885   }
72886   std::string arg1_str(jarg1);
72887   arg1 = &arg1_str;
72888   {
72889     try {
72890       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72891     } catch (std::out_of_range& e) {
72892       {
72893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (std::exception& e) {
72896       {
72897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (...) {
72900       {
72901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72902       };
72903     }
72904   }
72905   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72906
72907   //argout typemap for const std::string&
72908
72909   return jresult;
72910 }
72911
72912
72913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72914   void * jresult ;
72915   Dali::Toolkit::TextLabel *result = 0 ;
72916
72917   {
72918     try {
72919       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72920     } catch (std::out_of_range& e) {
72921       {
72922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72923       };
72924     } catch (std::exception& e) {
72925       {
72926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72927       };
72928     } catch (...) {
72929       {
72930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72931       };
72932     }
72933   }
72934   jresult = (void *)result;
72935   return jresult;
72936 }
72937
72938
72939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72940   void * jresult ;
72941   Dali::Toolkit::TextLabel *arg1 = 0 ;
72942   Dali::Toolkit::TextLabel *result = 0 ;
72943
72944   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72945   if (!arg1) {
72946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72947     return 0;
72948   }
72949   {
72950     try {
72951       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72952     } catch (std::out_of_range& e) {
72953       {
72954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72955       };
72956     } catch (std::exception& e) {
72957       {
72958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (...) {
72961       {
72962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72963       };
72964     }
72965   }
72966   jresult = (void *)result;
72967   return jresult;
72968 }
72969
72970
72971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72972   void * jresult ;
72973   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72974   Dali::Toolkit::TextLabel *arg2 = 0 ;
72975   Dali::Toolkit::TextLabel *result = 0 ;
72976
72977   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72978   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72979   if (!arg2) {
72980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72981     return 0;
72982   }
72983   {
72984     try {
72985       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
72986     } catch (std::out_of_range& e) {
72987       {
72988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72989       };
72990     } catch (std::exception& e) {
72991       {
72992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72993       };
72994     } catch (...) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72997       };
72998     }
72999   }
73000   jresult = (void *)result;
73001   return jresult;
73002 }
73003
73004
73005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
73006   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
73007
73008   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73009   {
73010     try {
73011       delete arg1;
73012     } catch (std::out_of_range& e) {
73013       {
73014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73015       };
73016     } catch (std::exception& e) {
73017       {
73018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73019       };
73020     } catch (...) {
73021       {
73022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73023       };
73024     }
73025   }
73026 }
73027
73028
73029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73030   void * jresult ;
73031   Dali::BaseHandle arg1 ;
73032   Dali::BaseHandle *argp1 ;
73033   Dali::Toolkit::TextLabel result;
73034
73035   argp1 = (Dali::BaseHandle *)jarg1;
73036   if (!argp1) {
73037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73038     return 0;
73039   }
73040   arg1 = *argp1;
73041   {
73042     try {
73043       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73044     } catch (std::out_of_range& e) {
73045       {
73046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73047       };
73048     } catch (std::exception& e) {
73049       {
73050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73051       };
73052     } catch (...) {
73053       {
73054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73055       };
73056     }
73057   }
73058   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73059   return jresult;
73060 }
73061
73062
73063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73064   void * jresult ;
73065   Dali::Toolkit::AccessibilityManager *result = 0 ;
73066
73067   {
73068     try {
73069       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73070     } catch (std::out_of_range& e) {
73071       {
73072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (std::exception& e) {
73075       {
73076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73081       };
73082     }
73083   }
73084   jresult = (void *)result;
73085   return jresult;
73086 }
73087
73088
73089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73090   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73091
73092   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73093   {
73094     try {
73095       delete arg1;
73096     } catch (std::out_of_range& e) {
73097       {
73098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73099       };
73100     } catch (std::exception& e) {
73101       {
73102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73107       };
73108     }
73109   }
73110 }
73111
73112
73113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73114   void * jresult ;
73115   Dali::Toolkit::AccessibilityManager result;
73116
73117   {
73118     try {
73119       result = Dali::Toolkit::AccessibilityManager::Get();
73120     } catch (std::out_of_range& e) {
73121       {
73122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73123       };
73124     } catch (std::exception& e) {
73125       {
73126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (...) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73131       };
73132     }
73133   }
73134   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73135   return jresult;
73136 }
73137
73138
73139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73141   Dali::Actor arg2 ;
73142   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73143   std::string *arg4 = 0 ;
73144   Dali::Actor *argp2 ;
73145
73146   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73147   argp2 = (Dali::Actor *)jarg2;
73148   if (!argp2) {
73149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73150     return ;
73151   }
73152   arg2 = *argp2;
73153   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73154   if (!jarg4) {
73155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73156     return ;
73157   }
73158   std::string arg4_str(jarg4);
73159   arg4 = &arg4_str;
73160   {
73161     try {
73162       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73163     } catch (std::out_of_range& e) {
73164       {
73165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73166       };
73167     } catch (std::exception& e) {
73168       {
73169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73174       };
73175     }
73176   }
73177
73178   //argout typemap for const std::string&
73179
73180 }
73181
73182
73183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73184   char * jresult ;
73185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73186   Dali::Actor arg2 ;
73187   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73188   Dali::Actor *argp2 ;
73189   std::string result;
73190
73191   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73192   argp2 = (Dali::Actor *)jarg2;
73193   if (!argp2) {
73194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73195     return 0;
73196   }
73197   arg2 = *argp2;
73198   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73199   {
73200     try {
73201       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73202     } catch (std::out_of_range& e) {
73203       {
73204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73205       };
73206     } catch (std::exception& e) {
73207       {
73208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73209       };
73210     } catch (...) {
73211       {
73212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73213       };
73214     }
73215   }
73216   jresult = SWIG_csharp_string_callback((&result)->c_str());
73217   return jresult;
73218 }
73219
73220
73221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73223   Dali::Actor arg2 ;
73224   unsigned int arg3 ;
73225   Dali::Actor *argp2 ;
73226
73227   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73228   argp2 = (Dali::Actor *)jarg2;
73229   if (!argp2) {
73230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73231     return ;
73232   }
73233   arg2 = *argp2;
73234   arg3 = (unsigned int)jarg3;
73235   {
73236     try {
73237       (arg1)->SetFocusOrder(arg2,arg3);
73238     } catch (std::out_of_range& e) {
73239       {
73240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73241       };
73242     } catch (std::exception& e) {
73243       {
73244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73245       };
73246     } catch (...) {
73247       {
73248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73249       };
73250     }
73251   }
73252 }
73253
73254
73255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73256   unsigned int jresult ;
73257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73258   Dali::Actor arg2 ;
73259   Dali::Actor *argp2 ;
73260   unsigned int result;
73261
73262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73263   argp2 = (Dali::Actor *)jarg2;
73264   if (!argp2) {
73265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73266     return 0;
73267   }
73268   arg2 = *argp2;
73269   {
73270     try {
73271       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73272     } catch (std::out_of_range& e) {
73273       {
73274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73275       };
73276     } catch (std::exception& e) {
73277       {
73278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73279       };
73280     } catch (...) {
73281       {
73282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73283       };
73284     }
73285   }
73286   jresult = result;
73287   return jresult;
73288 }
73289
73290
73291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73292   unsigned int jresult ;
73293   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73294   unsigned int result;
73295
73296   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73297   {
73298     try {
73299       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73300     } catch (std::out_of_range& e) {
73301       {
73302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73303       };
73304     } catch (std::exception& e) {
73305       {
73306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73307       };
73308     } catch (...) {
73309       {
73310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73311       };
73312     }
73313   }
73314   jresult = result;
73315   return jresult;
73316 }
73317
73318
73319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73320   void * jresult ;
73321   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73322   unsigned int arg2 ;
73323   Dali::Actor result;
73324
73325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73326   arg2 = (unsigned int)jarg2;
73327   {
73328     try {
73329       result = (arg1)->GetActorByFocusOrder(arg2);
73330     } catch (std::out_of_range& e) {
73331       {
73332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73333       };
73334     } catch (std::exception& e) {
73335       {
73336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73337       };
73338     } catch (...) {
73339       {
73340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73341       };
73342     }
73343   }
73344   jresult = new Dali::Actor((const Dali::Actor &)result);
73345   return jresult;
73346 }
73347
73348
73349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73350   unsigned int jresult ;
73351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73352   Dali::Actor arg2 ;
73353   Dali::Actor *argp2 ;
73354   bool result;
73355
73356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73357   argp2 = (Dali::Actor *)jarg2;
73358   if (!argp2) {
73359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73360     return 0;
73361   }
73362   arg2 = *argp2;
73363   {
73364     try {
73365       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73366     } catch (std::out_of_range& e) {
73367       {
73368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73369       };
73370     } catch (std::exception& e) {
73371       {
73372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73373       };
73374     } catch (...) {
73375       {
73376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73377       };
73378     }
73379   }
73380   jresult = result;
73381   return jresult;
73382 }
73383
73384
73385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73386   void * jresult ;
73387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73388   Dali::Actor result;
73389
73390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73391   {
73392     try {
73393       result = (arg1)->GetCurrentFocusActor();
73394     } catch (std::out_of_range& e) {
73395       {
73396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73397       };
73398     } catch (std::exception& e) {
73399       {
73400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (...) {
73403       {
73404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73405       };
73406     }
73407   }
73408   jresult = new Dali::Actor((const Dali::Actor &)result);
73409   return jresult;
73410 }
73411
73412
73413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73414   void * jresult ;
73415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73416   Dali::Actor result;
73417
73418   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73419   {
73420     try {
73421       result = (arg1)->GetCurrentFocusGroup();
73422     } catch (std::out_of_range& e) {
73423       {
73424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (std::exception& e) {
73427       {
73428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (...) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73433       };
73434     }
73435   }
73436   jresult = new Dali::Actor((const Dali::Actor &)result);
73437   return jresult;
73438 }
73439
73440
73441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73442   unsigned int jresult ;
73443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73444   unsigned int result;
73445
73446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73447   {
73448     try {
73449       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73450     } catch (std::out_of_range& e) {
73451       {
73452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73453       };
73454     } catch (std::exception& e) {
73455       {
73456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73457       };
73458     } catch (...) {
73459       {
73460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73461       };
73462     }
73463   }
73464   jresult = result;
73465   return jresult;
73466 }
73467
73468
73469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73470   unsigned int jresult ;
73471   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73472   bool result;
73473
73474   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73475   {
73476     try {
73477       result = (bool)(arg1)->MoveFocusForward();
73478     } catch (std::out_of_range& e) {
73479       {
73480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73481       };
73482     } catch (std::exception& e) {
73483       {
73484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73485       };
73486     } catch (...) {
73487       {
73488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73489       };
73490     }
73491   }
73492   jresult = result;
73493   return jresult;
73494 }
73495
73496
73497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73498   unsigned int jresult ;
73499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73500   bool result;
73501
73502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73503   {
73504     try {
73505       result = (bool)(arg1)->MoveFocusBackward();
73506     } catch (std::out_of_range& e) {
73507       {
73508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73509       };
73510     } catch (std::exception& e) {
73511       {
73512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (...) {
73515       {
73516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73517       };
73518     }
73519   }
73520   jresult = result;
73521   return jresult;
73522 }
73523
73524
73525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73527
73528   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73529   {
73530     try {
73531       (arg1)->ClearFocus();
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_Reset(void * jarg1) {
73550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73551
73552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73553   {
73554     try {
73555       (arg1)->Reset();
73556     } catch (std::out_of_range& e) {
73557       {
73558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73559       };
73560     } catch (std::exception& e) {
73561       {
73562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73563       };
73564     } catch (...) {
73565       {
73566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73567       };
73568     }
73569   }
73570 }
73571
73572
73573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73575   Dali::Actor arg2 ;
73576   bool arg3 ;
73577   Dali::Actor *argp2 ;
73578
73579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73580   argp2 = (Dali::Actor *)jarg2;
73581   if (!argp2) {
73582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73583     return ;
73584   }
73585   arg2 = *argp2;
73586   arg3 = jarg3 ? true : false;
73587   {
73588     try {
73589       (arg1)->SetFocusGroup(arg2,arg3);
73590     } catch (std::out_of_range& e) {
73591       {
73592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73593       };
73594     } catch (std::exception& e) {
73595       {
73596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73597       };
73598     } catch (...) {
73599       {
73600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73601       };
73602     }
73603   }
73604 }
73605
73606
73607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73608   unsigned int jresult ;
73609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73610   Dali::Actor arg2 ;
73611   Dali::Actor *argp2 ;
73612   bool result;
73613
73614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73615   argp2 = (Dali::Actor *)jarg2;
73616   if (!argp2) {
73617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73618     return 0;
73619   }
73620   arg2 = *argp2;
73621   {
73622     try {
73623       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73624     } catch (std::out_of_range& e) {
73625       {
73626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73627       };
73628     } catch (std::exception& e) {
73629       {
73630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73631       };
73632     } catch (...) {
73633       {
73634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73635       };
73636     }
73637   }
73638   jresult = result;
73639   return jresult;
73640 }
73641
73642
73643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73644   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73645   bool arg2 ;
73646
73647   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73648   arg2 = jarg2 ? true : false;
73649   {
73650     try {
73651       (arg1)->SetGroupMode(arg2);
73652     } catch (std::out_of_range& e) {
73653       {
73654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73655       };
73656     } catch (std::exception& e) {
73657       {
73658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73659       };
73660     } catch (...) {
73661       {
73662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73663       };
73664     }
73665   }
73666 }
73667
73668
73669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73670   unsigned int jresult ;
73671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73672   bool result;
73673
73674   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73675   {
73676     try {
73677       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73678     } catch (std::out_of_range& e) {
73679       {
73680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73681       };
73682     } catch (std::exception& e) {
73683       {
73684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73685       };
73686     } catch (...) {
73687       {
73688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73689       };
73690     }
73691   }
73692   jresult = result;
73693   return jresult;
73694 }
73695
73696
73697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73699   bool arg2 ;
73700
73701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73702   arg2 = jarg2 ? true : false;
73703   {
73704     try {
73705       (arg1)->SetWrapMode(arg2);
73706     } catch (std::out_of_range& e) {
73707       {
73708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73709       };
73710     } catch (std::exception& e) {
73711       {
73712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73713       };
73714     } catch (...) {
73715       {
73716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73717       };
73718     }
73719   }
73720 }
73721
73722
73723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73724   unsigned int jresult ;
73725   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73726   bool result;
73727
73728   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73729   {
73730     try {
73731       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73732     } catch (std::out_of_range& e) {
73733       {
73734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73735       };
73736     } catch (std::exception& e) {
73737       {
73738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73739       };
73740     } catch (...) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73743       };
73744     }
73745   }
73746   jresult = result;
73747   return jresult;
73748 }
73749
73750
73751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73753   Dali::Actor arg2 ;
73754   Dali::Actor *argp2 ;
73755
73756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73757   argp2 = (Dali::Actor *)jarg2;
73758   if (!argp2) {
73759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73760     return ;
73761   }
73762   arg2 = *argp2;
73763   {
73764     try {
73765       (arg1)->SetFocusIndicatorActor(arg2);
73766     } catch (std::out_of_range& e) {
73767       {
73768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73769       };
73770     } catch (std::exception& e) {
73771       {
73772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73773       };
73774     } catch (...) {
73775       {
73776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73777       };
73778     }
73779   }
73780 }
73781
73782
73783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73784   void * jresult ;
73785   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73786   Dali::Actor result;
73787
73788   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73789   {
73790     try {
73791       result = (arg1)->GetFocusIndicatorActor();
73792     } catch (std::out_of_range& e) {
73793       {
73794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73795       };
73796     } catch (std::exception& e) {
73797       {
73798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73803       };
73804     }
73805   }
73806   jresult = new Dali::Actor((const Dali::Actor &)result);
73807   return jresult;
73808 }
73809
73810
73811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73812   void * jresult ;
73813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73814   Dali::Actor arg2 ;
73815   Dali::Actor *argp2 ;
73816   Dali::Actor result;
73817
73818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73819   argp2 = (Dali::Actor *)jarg2;
73820   if (!argp2) {
73821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73822     return 0;
73823   }
73824   arg2 = *argp2;
73825   {
73826     try {
73827       result = (arg1)->GetFocusGroup(arg2);
73828     } catch (std::out_of_range& e) {
73829       {
73830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73831       };
73832     } catch (std::exception& e) {
73833       {
73834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73835       };
73836     } catch (...) {
73837       {
73838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73839       };
73840     }
73841   }
73842   jresult = new Dali::Actor((const Dali::Actor &)result);
73843   return jresult;
73844 }
73845
73846
73847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73848   void * jresult ;
73849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73850   Dali::Vector2 result;
73851
73852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73853   {
73854     try {
73855       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73856     } catch (std::out_of_range& e) {
73857       {
73858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (std::exception& e) {
73861       {
73862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73867       };
73868     }
73869   }
73870   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73871   return jresult;
73872 }
73873
73874
73875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73876   void * jresult ;
73877   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73878   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73879
73880   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73881   {
73882     try {
73883       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (...) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73895       };
73896     }
73897   }
73898   jresult = (void *)result;
73899   return jresult;
73900 }
73901
73902
73903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73904   void * jresult ;
73905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73906   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73907
73908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73909   {
73910     try {
73911       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73912     } catch (std::out_of_range& e) {
73913       {
73914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73915       };
73916     } catch (std::exception& e) {
73917       {
73918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73919       };
73920     } catch (...) {
73921       {
73922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73923       };
73924     }
73925   }
73926   jresult = (void *)result;
73927   return jresult;
73928 }
73929
73930
73931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73932   void * jresult ;
73933   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73934   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73935
73936   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73937   {
73938     try {
73939       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73940     } catch (std::out_of_range& e) {
73941       {
73942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73943       };
73944     } catch (std::exception& e) {
73945       {
73946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73947       };
73948     } catch (...) {
73949       {
73950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73951       };
73952     }
73953   }
73954   jresult = (void *)result;
73955   return jresult;
73956 }
73957
73958
73959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73960   void * jresult ;
73961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73963
73964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73965   {
73966     try {
73967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73968     } catch (std::out_of_range& e) {
73969       {
73970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73971       };
73972     } catch (std::exception& e) {
73973       {
73974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73975       };
73976     } catch (...) {
73977       {
73978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73979       };
73980     }
73981   }
73982   jresult = (void *)result;
73983   return jresult;
73984 }
73985
73986
73987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
73988   void * jresult ;
73989   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73990   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73991
73992   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73993   {
73994     try {
73995       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
73996     } catch (std::out_of_range& e) {
73997       {
73998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73999       };
74000     } catch (std::exception& e) {
74001       {
74002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74003       };
74004     } catch (...) {
74005       {
74006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74007       };
74008     }
74009   }
74010   jresult = (void *)result;
74011   return jresult;
74012 }
74013
74014
74015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
74016   void * jresult ;
74017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74019
74020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74021   {
74022     try {
74023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74024     } catch (std::out_of_range& e) {
74025       {
74026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74027       };
74028     } catch (std::exception& e) {
74029       {
74030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74031       };
74032     } catch (...) {
74033       {
74034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74035       };
74036     }
74037   }
74038   jresult = (void *)result;
74039   return jresult;
74040 }
74041
74042
74043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74044   void * jresult ;
74045   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74046   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74047
74048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74049   {
74050     try {
74051       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74052     } catch (std::out_of_range& e) {
74053       {
74054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74055       };
74056     } catch (std::exception& e) {
74057       {
74058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74059       };
74060     } catch (...) {
74061       {
74062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74063       };
74064     }
74065   }
74066   jresult = (void *)result;
74067   return jresult;
74068 }
74069
74070
74071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74072   void * jresult ;
74073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74074   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74075
74076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74077   {
74078     try {
74079       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74080     } catch (std::out_of_range& e) {
74081       {
74082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74083       };
74084     } catch (std::exception& e) {
74085       {
74086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74087       };
74088     } catch (...) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74091       };
74092     }
74093   }
74094   jresult = (void *)result;
74095   return jresult;
74096 }
74097
74098
74099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74100   void * jresult ;
74101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74102   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74103
74104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74105   {
74106     try {
74107       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74108     } catch (std::out_of_range& e) {
74109       {
74110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74111       };
74112     } catch (std::exception& e) {
74113       {
74114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74115       };
74116     } catch (...) {
74117       {
74118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74119       };
74120     }
74121   }
74122   jresult = (void *)result;
74123   return jresult;
74124 }
74125
74126
74127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74128   void * jresult ;
74129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74130   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74131
74132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74133   {
74134     try {
74135       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74136     } catch (std::out_of_range& e) {
74137       {
74138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74139       };
74140     } catch (std::exception& e) {
74141       {
74142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (...) {
74145       {
74146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74147       };
74148     }
74149   }
74150   jresult = (void *)result;
74151   return jresult;
74152 }
74153
74154
74155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74156   void * jresult ;
74157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74158   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74159
74160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74161   {
74162     try {
74163       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74164     } catch (std::out_of_range& e) {
74165       {
74166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74167       };
74168     } catch (std::exception& e) {
74169       {
74170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74171       };
74172     } catch (...) {
74173       {
74174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74175       };
74176     }
74177   }
74178   jresult = (void *)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74184   void * jresult ;
74185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74186   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74187
74188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74189   {
74190     try {
74191       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74192     } catch (std::out_of_range& e) {
74193       {
74194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74195       };
74196     } catch (std::exception& e) {
74197       {
74198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74199       };
74200     } catch (...) {
74201       {
74202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74203       };
74204     }
74205   }
74206   jresult = (void *)result;
74207   return jresult;
74208 }
74209
74210
74211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74212   void * jresult ;
74213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74215
74216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74217   {
74218     try {
74219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74220     } catch (std::out_of_range& e) {
74221       {
74222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74223       };
74224     } catch (std::exception& e) {
74225       {
74226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74227       };
74228     } catch (...) {
74229       {
74230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74231       };
74232     }
74233   }
74234   jresult = (void *)result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74240   void * jresult ;
74241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74242   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74243
74244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74245   {
74246     try {
74247       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74248     } catch (std::out_of_range& e) {
74249       {
74250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74251       };
74252     } catch (std::exception& e) {
74253       {
74254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74255       };
74256     } catch (...) {
74257       {
74258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74259       };
74260     }
74261   }
74262   jresult = (void *)result;
74263   return jresult;
74264 }
74265
74266
74267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74268   void * jresult ;
74269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74270   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74271
74272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74273   {
74274     try {
74275       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (...) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74287       };
74288     }
74289   }
74290   jresult = (void *)result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74296   void * jresult ;
74297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74298   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74299
74300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74301   {
74302     try {
74303       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74304     } catch (std::out_of_range& e) {
74305       {
74306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74307       };
74308     } catch (std::exception& e) {
74309       {
74310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74311       };
74312     } catch (...) {
74313       {
74314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74315       };
74316     }
74317   }
74318   jresult = (void *)result;
74319   return jresult;
74320 }
74321
74322
74323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74324   void * jresult ;
74325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74326   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74327
74328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74329   {
74330     try {
74331       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74332     } catch (std::out_of_range& e) {
74333       {
74334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74335       };
74336     } catch (std::exception& e) {
74337       {
74338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74339       };
74340     } catch (...) {
74341       {
74342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74343       };
74344     }
74345   }
74346   jresult = (void *)result;
74347   return jresult;
74348 }
74349
74350
74351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74352   void * jresult ;
74353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74354   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74355
74356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74357   {
74358     try {
74359       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74360     } catch (std::out_of_range& e) {
74361       {
74362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74363       };
74364     } catch (std::exception& e) {
74365       {
74366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74367       };
74368     } catch (...) {
74369       {
74370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74371       };
74372     }
74373   }
74374   jresult = (void *)result;
74375   return jresult;
74376 }
74377
74378
74379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74380   void * jresult ;
74381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74382   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74383
74384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74385   {
74386     try {
74387       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74388     } catch (std::out_of_range& e) {
74389       {
74390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (std::exception& e) {
74393       {
74394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74395       };
74396     } catch (...) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74399       };
74400     }
74401   }
74402   jresult = (void *)result;
74403   return jresult;
74404 }
74405
74406
74407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74408   void * jresult ;
74409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74410   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74411
74412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74413   {
74414     try {
74415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74416     } catch (std::out_of_range& e) {
74417       {
74418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74419       };
74420     } catch (std::exception& e) {
74421       {
74422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74423       };
74424     } catch (...) {
74425       {
74426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74427       };
74428     }
74429   }
74430   jresult = (void *)result;
74431   return jresult;
74432 }
74433
74434
74435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74436   void * jresult ;
74437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74438   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74439
74440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74441   {
74442     try {
74443       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74444     } catch (std::out_of_range& e) {
74445       {
74446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74447       };
74448     } catch (std::exception& e) {
74449       {
74450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74451       };
74452     } catch (...) {
74453       {
74454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74455       };
74456     }
74457   }
74458   jresult = (void *)result;
74459   return jresult;
74460 }
74461
74462
74463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74464   void * jresult ;
74465   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74466   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74467
74468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74469   {
74470     try {
74471       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74472     } catch (std::out_of_range& e) {
74473       {
74474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74475       };
74476     } catch (std::exception& e) {
74477       {
74478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74479       };
74480     } catch (...) {
74481       {
74482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74483       };
74484     }
74485   }
74486   jresult = (void *)result;
74487   return jresult;
74488 }
74489
74490
74491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74492   void * jresult ;
74493   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74494   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74495
74496   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74497   {
74498     try {
74499       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74500     } catch (std::out_of_range& e) {
74501       {
74502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74503       };
74504     } catch (std::exception& e) {
74505       {
74506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74507       };
74508     } catch (...) {
74509       {
74510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74511       };
74512     }
74513   }
74514   jresult = (void *)result;
74515   return jresult;
74516 }
74517
74518
74519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74520   void * jresult ;
74521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74522   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74523
74524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74525   {
74526     try {
74527       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74528     } catch (std::out_of_range& e) {
74529       {
74530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74531       };
74532     } catch (std::exception& e) {
74533       {
74534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74539       };
74540     }
74541   }
74542   jresult = (void *)result;
74543   return jresult;
74544 }
74545
74546
74547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74548   void * jresult ;
74549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74550   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74551
74552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74553   {
74554     try {
74555       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (...) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74567       };
74568     }
74569   }
74570   jresult = (void *)result;
74571   return jresult;
74572 }
74573
74574
74575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74576   void * jresult ;
74577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74578   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74579
74580   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74581   {
74582     try {
74583       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74584     } catch (std::out_of_range& e) {
74585       {
74586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74587       };
74588     } catch (std::exception& e) {
74589       {
74590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74591       };
74592     } catch (...) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74595       };
74596     }
74597   }
74598   jresult = (void *)result;
74599   return jresult;
74600 }
74601
74602
74603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74604   void * jresult ;
74605   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74606   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74607
74608   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74609   {
74610     try {
74611       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74612     } catch (std::out_of_range& e) {
74613       {
74614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74615       };
74616     } catch (std::exception& e) {
74617       {
74618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74619       };
74620     } catch (...) {
74621       {
74622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74623       };
74624     }
74625   }
74626   jresult = (void *)result;
74627   return jresult;
74628 }
74629
74630
74631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74632   void * jresult ;
74633   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74634   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74635
74636   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74637   {
74638     try {
74639       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74640     } catch (std::out_of_range& e) {
74641       {
74642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74643       };
74644     } catch (std::exception& e) {
74645       {
74646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74647       };
74648     } catch (...) {
74649       {
74650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74651       };
74652     }
74653   }
74654   jresult = (void *)result;
74655   return jresult;
74656 }
74657
74658
74659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74660   void * jresult ;
74661   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74662   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74663
74664   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74665   {
74666     try {
74667       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74668     } catch (std::out_of_range& e) {
74669       {
74670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74671       };
74672     } catch (std::exception& e) {
74673       {
74674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74675       };
74676     } catch (...) {
74677       {
74678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74679       };
74680     }
74681   }
74682   jresult = (void *)result;
74683   return jresult;
74684 }
74685
74686
74687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74688   void * jresult ;
74689   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74690   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74691
74692   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74693   {
74694     try {
74695       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74696     } catch (std::out_of_range& e) {
74697       {
74698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74699       };
74700     } catch (std::exception& e) {
74701       {
74702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74703       };
74704     } catch (...) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74707       };
74708     }
74709   }
74710   jresult = (void *)result;
74711   return jresult;
74712 }
74713
74714
74715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74716   void * jresult ;
74717   Dali::Toolkit::StyleManager *result = 0 ;
74718
74719   {
74720     try {
74721       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74722     } catch (std::out_of_range& e) {
74723       {
74724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (std::exception& e) {
74727       {
74728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74729       };
74730     } catch (...) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74733       };
74734     }
74735   }
74736   jresult = (void *)result;
74737   return jresult;
74738 }
74739
74740
74741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74742   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74743
74744   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74745   {
74746     try {
74747       delete arg1;
74748     } catch (std::out_of_range& e) {
74749       {
74750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74751       };
74752     } catch (std::exception& e) {
74753       {
74754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74755       };
74756     } catch (...) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74759       };
74760     }
74761   }
74762 }
74763
74764
74765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74766   void * jresult ;
74767   Dali::Toolkit::StyleManager result;
74768
74769   {
74770     try {
74771       result = Dali::Toolkit::StyleManager::Get();
74772     } catch (std::out_of_range& e) {
74773       {
74774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74775       };
74776     } catch (std::exception& e) {
74777       {
74778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74779       };
74780     } catch (...) {
74781       {
74782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74783       };
74784     }
74785   }
74786   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74787   return jresult;
74788 }
74789
74790
74791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74792   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74793   std::string *arg2 = 0 ;
74794
74795   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74796   if (!jarg2) {
74797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74798     return ;
74799   }
74800   std::string arg2_str(jarg2);
74801   arg2 = &arg2_str;
74802   {
74803     try {
74804       (arg1)->ApplyTheme((std::string const &)*arg2);
74805     } catch (std::out_of_range& e) {
74806       {
74807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74808       };
74809     } catch (std::exception& e) {
74810       {
74811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74812       };
74813     } catch (...) {
74814       {
74815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74816       };
74817     }
74818   }
74819
74820   //argout typemap for const std::string&
74821
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74826   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74827
74828   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74829   {
74830     try {
74831       (arg1)->ApplyDefaultTheme();
74832     } catch (std::out_of_range& e) {
74833       {
74834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (std::exception& e) {
74837       {
74838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74839       };
74840     } catch (...) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74843       };
74844     }
74845   }
74846 }
74847
74848
74849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74850   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74851   std::string *arg2 = 0 ;
74852   Dali::Property::Value *arg3 = 0 ;
74853
74854   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74855   if (!jarg2) {
74856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74857     return ;
74858   }
74859   std::string arg2_str(jarg2);
74860   arg2 = &arg2_str;
74861   arg3 = (Dali::Property::Value *)jarg3;
74862   if (!arg3) {
74863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74864     return ;
74865   }
74866   {
74867     try {
74868       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74869     } catch (std::out_of_range& e) {
74870       {
74871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74872       };
74873     } catch (std::exception& e) {
74874       {
74875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74876       };
74877     } catch (...) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74880       };
74881     }
74882   }
74883
74884   //argout typemap for const std::string&
74885
74886 }
74887
74888
74889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74890   unsigned int jresult ;
74891   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74892   std::string *arg2 = 0 ;
74893   Dali::Property::Value *arg3 = 0 ;
74894   bool result;
74895
74896   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74897   if (!jarg2) {
74898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74899     return 0;
74900   }
74901   std::string arg2_str(jarg2);
74902   arg2 = &arg2_str;
74903   arg3 = (Dali::Property::Value *)jarg3;
74904   if (!arg3) {
74905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74906     return 0;
74907   }
74908   {
74909     try {
74910       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (...) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74922       };
74923     }
74924   }
74925   jresult = result;
74926
74927   //argout typemap for const std::string&
74928
74929   return jresult;
74930 }
74931
74932
74933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74934   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74935   Dali::Toolkit::Control arg2 ;
74936   std::string *arg3 = 0 ;
74937   std::string *arg4 = 0 ;
74938   Dali::Toolkit::Control *argp2 ;
74939
74940   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74941   argp2 = (Dali::Toolkit::Control *)jarg2;
74942   if (!argp2) {
74943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74944     return ;
74945   }
74946   arg2 = *argp2;
74947   if (!jarg3) {
74948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74949     return ;
74950   }
74951   std::string arg3_str(jarg3);
74952   arg3 = &arg3_str;
74953   if (!jarg4) {
74954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74955     return ;
74956   }
74957   std::string arg4_str(jarg4);
74958   arg4 = &arg4_str;
74959   {
74960     try {
74961       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74962     } catch (std::out_of_range& e) {
74963       {
74964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74965       };
74966     } catch (std::exception& e) {
74967       {
74968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74969       };
74970     } catch (...) {
74971       {
74972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74973       };
74974     }
74975   }
74976
74977   //argout typemap for const std::string&
74978
74979
74980   //argout typemap for const std::string&
74981
74982 }
74983
74984
74985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
74986   void * jresult ;
74987   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74988   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
74989
74990   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74991   {
74992     try {
74993       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
74994     } catch (std::out_of_range& e) {
74995       {
74996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74997       };
74998     } catch (std::exception& e) {
74999       {
75000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75001       };
75002     } catch (...) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75005       };
75006     }
75007   }
75008   jresult = (void *)result;
75009   return jresult;
75010 }
75011
75012
75013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
75014   int jresult ;
75015   int result;
75016
75017   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
75018   jresult = (int)result;
75019   return jresult;
75020 }
75021
75022
75023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75024   int jresult ;
75025   int result;
75026
75027   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75028   jresult = (int)result;
75029   return jresult;
75030 }
75031
75032
75033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75034   int jresult ;
75035   int result;
75036
75037   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75038   jresult = (int)result;
75039   return jresult;
75040 }
75041
75042
75043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75044   int jresult ;
75045   int result;
75046
75047   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75048   jresult = (int)result;
75049   return jresult;
75050 }
75051
75052
75053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75054   int jresult ;
75055   int result;
75056
75057   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75058   jresult = (int)result;
75059   return jresult;
75060 }
75061
75062
75063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75064   int jresult ;
75065   int result;
75066
75067   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75068   jresult = (int)result;
75069   return jresult;
75070 }
75071
75072
75073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75074   int jresult ;
75075   int result;
75076
75077   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75078   jresult = (int)result;
75079   return jresult;
75080 }
75081
75082
75083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75084   int jresult ;
75085   int result;
75086
75087   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75088   jresult = (int)result;
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75094   int jresult ;
75095   int result;
75096
75097   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75098   jresult = (int)result;
75099   return jresult;
75100 }
75101
75102
75103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75104   int jresult ;
75105   int result;
75106
75107   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75108   jresult = (int)result;
75109   return jresult;
75110 }
75111
75112
75113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75114   int jresult ;
75115   int result;
75116
75117   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75118   jresult = (int)result;
75119   return jresult;
75120 }
75121
75122
75123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75124   int jresult ;
75125   int result;
75126
75127   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75128   jresult = (int)result;
75129   return jresult;
75130 }
75131
75132
75133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75134   int jresult ;
75135   int result;
75136
75137   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75138   jresult = (int)result;
75139   return jresult;
75140 }
75141
75142
75143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75144   int jresult ;
75145   int result;
75146
75147   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75148   jresult = (int)result;
75149   return jresult;
75150 }
75151
75152
75153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75154   int jresult ;
75155   int result;
75156
75157   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75158   jresult = (int)result;
75159   return jresult;
75160 }
75161
75162
75163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75164   void * jresult ;
75165   Dali::Toolkit::Slider::Property *result = 0 ;
75166
75167   {
75168     try {
75169       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75170     } catch (std::out_of_range& e) {
75171       {
75172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75173       };
75174     } catch (std::exception& e) {
75175       {
75176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75177       };
75178     } catch (...) {
75179       {
75180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75181       };
75182     }
75183   }
75184   jresult = (void *)result;
75185   return jresult;
75186 }
75187
75188
75189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75190   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75191
75192   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75193   {
75194     try {
75195       delete arg1;
75196     } catch (std::out_of_range& e) {
75197       {
75198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75199       };
75200     } catch (std::exception& e) {
75201       {
75202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75203       };
75204     } catch (...) {
75205       {
75206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75207       };
75208     }
75209   }
75210 }
75211
75212
75213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75214   void * jresult ;
75215   Dali::Toolkit::Slider result;
75216
75217   {
75218     try {
75219       result = Dali::Toolkit::Slider::New();
75220     } catch (std::out_of_range& e) {
75221       {
75222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75223       };
75224     } catch (std::exception& e) {
75225       {
75226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75227       };
75228     } catch (...) {
75229       {
75230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75231       };
75232     }
75233   }
75234   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75235   return jresult;
75236 }
75237
75238
75239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75240   void * jresult ;
75241   Dali::Toolkit::Slider *result = 0 ;
75242
75243   {
75244     try {
75245       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75246     } catch (std::out_of_range& e) {
75247       {
75248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75249       };
75250     } catch (std::exception& e) {
75251       {
75252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75257       };
75258     }
75259   }
75260   jresult = (void *)result;
75261   return jresult;
75262 }
75263
75264
75265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75266   void * jresult ;
75267   Dali::Toolkit::Slider *arg1 = 0 ;
75268   Dali::Toolkit::Slider *result = 0 ;
75269
75270   arg1 = (Dali::Toolkit::Slider *)jarg1;
75271   if (!arg1) {
75272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75273     return 0;
75274   }
75275   {
75276     try {
75277       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75278     } catch (std::out_of_range& e) {
75279       {
75280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75281       };
75282     } catch (std::exception& e) {
75283       {
75284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75285       };
75286     } catch (...) {
75287       {
75288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75289       };
75290     }
75291   }
75292   jresult = (void *)result;
75293   return jresult;
75294 }
75295
75296
75297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75298   void * jresult ;
75299   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75300   Dali::Toolkit::Slider *arg2 = 0 ;
75301   Dali::Toolkit::Slider *result = 0 ;
75302
75303   arg1 = (Dali::Toolkit::Slider *)jarg1;
75304   arg2 = (Dali::Toolkit::Slider *)jarg2;
75305   if (!arg2) {
75306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75307     return 0;
75308   }
75309   {
75310     try {
75311       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75312     } catch (std::out_of_range& e) {
75313       {
75314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75315       };
75316     } catch (std::exception& e) {
75317       {
75318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75319       };
75320     } catch (...) {
75321       {
75322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75323       };
75324     }
75325   }
75326   jresult = (void *)result;
75327   return jresult;
75328 }
75329
75330
75331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75332   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75333
75334   arg1 = (Dali::Toolkit::Slider *)jarg1;
75335   {
75336     try {
75337       delete arg1;
75338     } catch (std::out_of_range& e) {
75339       {
75340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75341       };
75342     } catch (std::exception& e) {
75343       {
75344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75345       };
75346     } catch (...) {
75347       {
75348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75349       };
75350     }
75351   }
75352 }
75353
75354
75355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75356   void * jresult ;
75357   Dali::BaseHandle arg1 ;
75358   Dali::BaseHandle *argp1 ;
75359   Dali::Toolkit::Slider result;
75360
75361   argp1 = (Dali::BaseHandle *)jarg1;
75362   if (!argp1) {
75363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75364     return 0;
75365   }
75366   arg1 = *argp1;
75367   {
75368     try {
75369       result = Dali::Toolkit::Slider::DownCast(arg1);
75370     } catch (std::out_of_range& e) {
75371       {
75372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75373       };
75374     } catch (std::exception& e) {
75375       {
75376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75377       };
75378     } catch (...) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75381       };
75382     }
75383   }
75384   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75385   return jresult;
75386 }
75387
75388
75389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75390   void * jresult ;
75391   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75392   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75393
75394   arg1 = (Dali::Toolkit::Slider *)jarg1;
75395   {
75396     try {
75397       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75398     } catch (std::out_of_range& e) {
75399       {
75400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75401       };
75402     } catch (std::exception& e) {
75403       {
75404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75405       };
75406     } catch (...) {
75407       {
75408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75409       };
75410     }
75411   }
75412   jresult = (void *)result;
75413   return jresult;
75414 }
75415
75416
75417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75418   void * jresult ;
75419   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75420   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75421
75422   arg1 = (Dali::Toolkit::Slider *)jarg1;
75423   {
75424     try {
75425       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75426     } catch (std::out_of_range& e) {
75427       {
75428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75429       };
75430     } catch (std::exception& e) {
75431       {
75432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75433       };
75434     } catch (...) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75437       };
75438     }
75439   }
75440   jresult = (void *)result;
75441   return jresult;
75442 }
75443
75444
75445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75446   void * jresult ;
75447   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75448   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75449
75450   arg1 = (Dali::Toolkit::Slider *)jarg1;
75451   {
75452     try {
75453       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75454     } catch (std::out_of_range& e) {
75455       {
75456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75457       };
75458     } catch (std::exception& e) {
75459       {
75460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75461       };
75462     } catch (...) {
75463       {
75464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75465       };
75466     }
75467   }
75468   jresult = (void *)result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75474   int jresult ;
75475   int result;
75476
75477   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75478   jresult = (int)result;
75479   return jresult;
75480 }
75481
75482
75483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75484   int jresult ;
75485   int result;
75486
75487   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75488   jresult = (int)result;
75489   return jresult;
75490 }
75491
75492
75493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75494   int jresult ;
75495   int result;
75496
75497   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75498   jresult = (int)result;
75499   return jresult;
75500 }
75501
75502
75503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75504   int jresult ;
75505   int result;
75506
75507   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75508   jresult = (int)result;
75509   return jresult;
75510 }
75511
75512
75513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75514   void * jresult ;
75515   Dali::Toolkit::VideoView::Property *result = 0 ;
75516
75517   {
75518     try {
75519       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75520     } catch (std::out_of_range& e) {
75521       {
75522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75523       };
75524     } catch (std::exception& e) {
75525       {
75526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (...) {
75529       {
75530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75531       };
75532     }
75533   }
75534   jresult = (void *)result;
75535   return jresult;
75536 }
75537
75538
75539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75540   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75541
75542   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75543   {
75544     try {
75545       delete arg1;
75546     } catch (std::out_of_range& e) {
75547       {
75548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75549       };
75550     } catch (std::exception& e) {
75551       {
75552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75553       };
75554     } catch (...) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75557       };
75558     }
75559   }
75560 }
75561
75562
75563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75564   void * jresult ;
75565   Dali::Toolkit::VideoView result;
75566
75567   {
75568     try {
75569       result = Dali::Toolkit::VideoView::New();
75570     } catch (std::out_of_range& e) {
75571       {
75572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75573       };
75574     } catch (std::exception& e) {
75575       {
75576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75577       };
75578     } catch (...) {
75579       {
75580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75581       };
75582     }
75583   }
75584   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75585   return jresult;
75586 }
75587
75588
75589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75590   void * jresult ;
75591   std::string *arg1 = 0 ;
75592   Dali::Toolkit::VideoView result;
75593
75594   if (!jarg1) {
75595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75596     return 0;
75597   }
75598   std::string arg1_str(jarg1);
75599   arg1 = &arg1_str;
75600   {
75601     try {
75602       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75603     } catch (std::out_of_range& e) {
75604       {
75605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75606       };
75607     } catch (std::exception& e) {
75608       {
75609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75610       };
75611     } catch (...) {
75612       {
75613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75614       };
75615     }
75616   }
75617   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75618
75619   //argout typemap for const std::string&
75620
75621   return jresult;
75622 }
75623
75624
75625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75626   void * jresult ;
75627   Dali::Toolkit::VideoView *result = 0 ;
75628
75629   {
75630     try {
75631       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75632     } catch (std::out_of_range& e) {
75633       {
75634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75635       };
75636     } catch (std::exception& e) {
75637       {
75638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75639       };
75640     } catch (...) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75643       };
75644     }
75645   }
75646   jresult = (void *)result;
75647   return jresult;
75648 }
75649
75650
75651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75652   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75653
75654   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75655   {
75656     try {
75657       delete arg1;
75658     } catch (std::out_of_range& e) {
75659       {
75660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75661       };
75662     } catch (std::exception& e) {
75663       {
75664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75665       };
75666     } catch (...) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75669       };
75670     }
75671   }
75672 }
75673
75674
75675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75676   void * jresult ;
75677   Dali::Toolkit::VideoView *arg1 = 0 ;
75678   Dali::Toolkit::VideoView *result = 0 ;
75679
75680   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75681   if (!arg1) {
75682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75683     return 0;
75684   }
75685   {
75686     try {
75687       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75688     } catch (std::out_of_range& e) {
75689       {
75690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75691       };
75692     } catch (std::exception& e) {
75693       {
75694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75695       };
75696     } catch (...) {
75697       {
75698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75699       };
75700     }
75701   }
75702   jresult = (void *)result;
75703   return jresult;
75704 }
75705
75706
75707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75708   void * jresult ;
75709   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75710   Dali::Toolkit::VideoView *arg2 = 0 ;
75711   Dali::Toolkit::VideoView *result = 0 ;
75712
75713   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75714   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75715   if (!arg2) {
75716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75717     return 0;
75718   }
75719   {
75720     try {
75721       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75722     } catch (std::out_of_range& e) {
75723       {
75724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75725       };
75726     } catch (std::exception& e) {
75727       {
75728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75729       };
75730     } catch (...) {
75731       {
75732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75733       };
75734     }
75735   }
75736   jresult = (void *)result;
75737   return jresult;
75738 }
75739
75740
75741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75742   void * jresult ;
75743   Dali::BaseHandle arg1 ;
75744   Dali::BaseHandle *argp1 ;
75745   Dali::Toolkit::VideoView result;
75746
75747   argp1 = (Dali::BaseHandle *)jarg1;
75748   if (!argp1) {
75749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75750     return 0;
75751   }
75752   arg1 = *argp1;
75753   {
75754     try {
75755       result = Dali::Toolkit::VideoView::DownCast(arg1);
75756     } catch (std::out_of_range& e) {
75757       {
75758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75759       };
75760     } catch (std::exception& e) {
75761       {
75762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75763       };
75764     } catch (...) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75767       };
75768     }
75769   }
75770   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75771   return jresult;
75772 }
75773
75774
75775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75776   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75777
75778   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75779   {
75780     try {
75781       (arg1)->Play();
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_Pause(void * jarg1) {
75800   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75801
75802   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75803   {
75804     try {
75805       (arg1)->Pause();
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_Stop(void * jarg1) {
75824   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75825
75826   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75827   {
75828     try {
75829       (arg1)->Stop();
75830     } catch (std::out_of_range& e) {
75831       {
75832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75833       };
75834     } catch (std::exception& e) {
75835       {
75836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75837       };
75838     } catch (...) {
75839       {
75840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75841       };
75842     }
75843   }
75844 }
75845
75846
75847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75848   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75849   int arg2 ;
75850
75851   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75852   arg2 = (int)jarg2;
75853   {
75854     try {
75855       (arg1)->Forward(arg2);
75856     } catch (std::out_of_range& e) {
75857       {
75858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75859       };
75860     } catch (std::exception& e) {
75861       {
75862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75863       };
75864     } catch (...) {
75865       {
75866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75867       };
75868     }
75869   }
75870 }
75871
75872
75873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
75874   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75875   int arg2 ;
75876
75877   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75878   arg2 = (int)jarg2;
75879   {
75880     try {
75881       (arg1)->Backward(arg2);
75882     } catch (std::out_of_range& e) {
75883       {
75884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75885       };
75886     } catch (std::exception& e) {
75887       {
75888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75889       };
75890     } catch (...) {
75891       {
75892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75893       };
75894     }
75895   }
75896 }
75897
75898
75899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75900   void * jresult ;
75901   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75902   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75903
75904   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75905   {
75906     try {
75907       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75908     } catch (std::out_of_range& e) {
75909       {
75910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75911       };
75912     } catch (std::exception& e) {
75913       {
75914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75915       };
75916     } catch (...) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75919       };
75920     }
75921   }
75922   jresult = (void *)result;
75923   return jresult;
75924 }
75925
75926
75927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75928   int jresult ;
75929   int result;
75930
75931   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75932   jresult = (int)result;
75933   return jresult;
75934 }
75935
75936
75937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75938   int jresult ;
75939   int result;
75940
75941   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75942   jresult = (int)result;
75943   return jresult;
75944 }
75945
75946
75947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75948   int jresult ;
75949   int result;
75950
75951   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75952   jresult = (int)result;
75953   return jresult;
75954 }
75955
75956
75957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75958   int jresult ;
75959   int result;
75960
75961   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75962   jresult = (int)result;
75963   return jresult;
75964 }
75965
75966
75967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75968   int jresult ;
75969   int result;
75970
75971   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75972   jresult = (int)result;
75973   return jresult;
75974 }
75975
75976
75977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75978   int jresult ;
75979   int result;
75980
75981   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
75982   jresult = (int)result;
75983   return jresult;
75984 }
75985
75986
75987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
75988   int jresult ;
75989   int result;
75990
75991   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
75992   jresult = (int)result;
75993   return jresult;
75994 }
75995
75996
75997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
75998   int jresult ;
75999   int result;
76000
76001   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
76002   jresult = (int)result;
76003   return jresult;
76004 }
76005
76006
76007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
76008   int jresult ;
76009   int result;
76010
76011   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
76012   jresult = (int)result;
76013   return jresult;
76014 }
76015
76016
76017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
76018   int jresult ;
76019   int result;
76020
76021   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
76022   jresult = (int)result;
76023   return jresult;
76024 }
76025
76026
76027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76028   int jresult ;
76029   int result;
76030
76031   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76032   jresult = (int)result;
76033   return jresult;
76034 }
76035
76036
76037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76038   int jresult ;
76039   int result;
76040
76041   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76042   jresult = (int)result;
76043   return jresult;
76044 }
76045
76046
76047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76048   int jresult ;
76049   int result;
76050
76051   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76052   jresult = (int)result;
76053   return jresult;
76054 }
76055
76056
76057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76058   int jresult ;
76059   int result;
76060
76061   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76062   jresult = (int)result;
76063   return jresult;
76064 }
76065
76066
76067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76068   int jresult ;
76069   int result;
76070
76071   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76072   jresult = (int)result;
76073   return jresult;
76074 }
76075
76076
76077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76078   int jresult ;
76079   int result;
76080
76081   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76082   jresult = (int)result;
76083   return jresult;
76084 }
76085
76086
76087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76088   int jresult ;
76089   int result;
76090
76091   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76092   jresult = (int)result;
76093   return jresult;
76094 }
76095
76096
76097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76098   int jresult ;
76099   int result;
76100
76101   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76102   jresult = (int)result;
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76108   int jresult ;
76109   int result;
76110
76111   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76112   jresult = (int)result;
76113   return jresult;
76114 }
76115
76116
76117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76118   int jresult ;
76119   int result;
76120
76121   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76122   jresult = (int)result;
76123   return jresult;
76124 }
76125
76126
76127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76128   int jresult ;
76129   int result;
76130
76131   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76132   jresult = (int)result;
76133   return jresult;
76134 }
76135
76136
76137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76138   void * jresult ;
76139   Dali::Toolkit::Popup::Property *result = 0 ;
76140
76141   {
76142     try {
76143       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76144     } catch (std::out_of_range& e) {
76145       {
76146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76147       };
76148     } catch (std::exception& e) {
76149       {
76150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76151       };
76152     } catch (...) {
76153       {
76154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76155       };
76156     }
76157   }
76158   jresult = (void *)result;
76159   return jresult;
76160 }
76161
76162
76163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76164   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76165
76166   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76167   {
76168     try {
76169       delete arg1;
76170     } catch (std::out_of_range& e) {
76171       {
76172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76173       };
76174     } catch (std::exception& e) {
76175       {
76176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76177       };
76178     } catch (...) {
76179       {
76180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76181       };
76182     }
76183   }
76184 }
76185
76186
76187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76188   void * jresult ;
76189   Dali::Toolkit::Popup *result = 0 ;
76190
76191   {
76192     try {
76193       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76194     } catch (std::out_of_range& e) {
76195       {
76196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76197       };
76198     } catch (std::exception& e) {
76199       {
76200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76201       };
76202     } catch (...) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76205       };
76206     }
76207   }
76208   jresult = (void *)result;
76209   return jresult;
76210 }
76211
76212
76213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76214   void * jresult ;
76215   Dali::Toolkit::Popup result;
76216
76217   {
76218     try {
76219       result = Dali::Toolkit::Popup::New();
76220     } catch (std::out_of_range& e) {
76221       {
76222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76223       };
76224     } catch (std::exception& e) {
76225       {
76226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76227       };
76228     } catch (...) {
76229       {
76230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76231       };
76232     }
76233   }
76234   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76235   return jresult;
76236 }
76237
76238
76239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76240   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76241
76242   arg1 = (Dali::Toolkit::Popup *)jarg1;
76243   {
76244     try {
76245       delete arg1;
76246     } catch (std::out_of_range& e) {
76247       {
76248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76249       };
76250     } catch (std::exception& e) {
76251       {
76252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76253       };
76254     } catch (...) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76257       };
76258     }
76259   }
76260 }
76261
76262
76263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76264   void * jresult ;
76265   Dali::Toolkit::Popup *arg1 = 0 ;
76266   Dali::Toolkit::Popup *result = 0 ;
76267
76268   arg1 = (Dali::Toolkit::Popup *)jarg1;
76269   if (!arg1) {
76270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76271     return 0;
76272   }
76273   {
76274     try {
76275       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76276     } catch (std::out_of_range& e) {
76277       {
76278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76279       };
76280     } catch (std::exception& e) {
76281       {
76282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76283       };
76284     } catch (...) {
76285       {
76286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76287       };
76288     }
76289   }
76290   jresult = (void *)result;
76291   return jresult;
76292 }
76293
76294
76295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76296   void * jresult ;
76297   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76298   Dali::Toolkit::Popup *arg2 = 0 ;
76299   Dali::Toolkit::Popup *result = 0 ;
76300
76301   arg1 = (Dali::Toolkit::Popup *)jarg1;
76302   arg2 = (Dali::Toolkit::Popup *)jarg2;
76303   if (!arg2) {
76304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76305     return 0;
76306   }
76307   {
76308     try {
76309       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76310     } catch (std::out_of_range& e) {
76311       {
76312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76313       };
76314     } catch (std::exception& e) {
76315       {
76316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76317       };
76318     } catch (...) {
76319       {
76320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76321       };
76322     }
76323   }
76324   jresult = (void *)result;
76325   return jresult;
76326 }
76327
76328
76329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76330   void * jresult ;
76331   Dali::BaseHandle arg1 ;
76332   Dali::BaseHandle *argp1 ;
76333   Dali::Toolkit::Popup result;
76334
76335   argp1 = (Dali::BaseHandle *)jarg1;
76336   if (!argp1) {
76337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76338     return 0;
76339   }
76340   arg1 = *argp1;
76341   {
76342     try {
76343       result = Dali::Toolkit::Popup::DownCast(arg1);
76344     } catch (std::out_of_range& e) {
76345       {
76346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76347       };
76348     } catch (std::exception& e) {
76349       {
76350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (...) {
76353       {
76354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76355       };
76356     }
76357   }
76358   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76359   return jresult;
76360 }
76361
76362
76363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76364   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76365   Dali::Actor arg2 ;
76366   Dali::Actor *argp2 ;
76367
76368   arg1 = (Dali::Toolkit::Popup *)jarg1;
76369   argp2 = (Dali::Actor *)jarg2;
76370   if (!argp2) {
76371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76372     return ;
76373   }
76374   arg2 = *argp2;
76375   {
76376     try {
76377       (arg1)->SetTitle(arg2);
76378     } catch (std::out_of_range& e) {
76379       {
76380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76381       };
76382     } catch (std::exception& e) {
76383       {
76384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76385       };
76386     } catch (...) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76389       };
76390     }
76391   }
76392 }
76393
76394
76395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76396   void * jresult ;
76397   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76398   Dali::Actor result;
76399
76400   arg1 = (Dali::Toolkit::Popup *)jarg1;
76401   {
76402     try {
76403       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76404     } catch (std::out_of_range& e) {
76405       {
76406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76407       };
76408     } catch (std::exception& e) {
76409       {
76410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76411       };
76412     } catch (...) {
76413       {
76414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76415       };
76416     }
76417   }
76418   jresult = new Dali::Actor((const Dali::Actor &)result);
76419   return jresult;
76420 }
76421
76422
76423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76424   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76425   Dali::Actor arg2 ;
76426   Dali::Actor *argp2 ;
76427
76428   arg1 = (Dali::Toolkit::Popup *)jarg1;
76429   argp2 = (Dali::Actor *)jarg2;
76430   if (!argp2) {
76431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76432     return ;
76433   }
76434   arg2 = *argp2;
76435   {
76436     try {
76437       (arg1)->SetContent(arg2);
76438     } catch (std::out_of_range& e) {
76439       {
76440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76441       };
76442     } catch (std::exception& e) {
76443       {
76444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76445       };
76446     } catch (...) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76449       };
76450     }
76451   }
76452 }
76453
76454
76455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76456   void * jresult ;
76457   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76458   Dali::Actor result;
76459
76460   arg1 = (Dali::Toolkit::Popup *)jarg1;
76461   {
76462     try {
76463       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76464     } catch (std::out_of_range& e) {
76465       {
76466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76467       };
76468     } catch (std::exception& e) {
76469       {
76470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76471       };
76472     } catch (...) {
76473       {
76474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76475       };
76476     }
76477   }
76478   jresult = new Dali::Actor((const Dali::Actor &)result);
76479   return jresult;
76480 }
76481
76482
76483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76484   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76485   Dali::Actor arg2 ;
76486   Dali::Actor *argp2 ;
76487
76488   arg1 = (Dali::Toolkit::Popup *)jarg1;
76489   argp2 = (Dali::Actor *)jarg2;
76490   if (!argp2) {
76491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76492     return ;
76493   }
76494   arg2 = *argp2;
76495   {
76496     try {
76497       (arg1)->SetFooter(arg2);
76498     } catch (std::out_of_range& e) {
76499       {
76500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76501       };
76502     } catch (std::exception& e) {
76503       {
76504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76505       };
76506     } catch (...) {
76507       {
76508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76509       };
76510     }
76511   }
76512 }
76513
76514
76515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76516   void * jresult ;
76517   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76518   Dali::Actor result;
76519
76520   arg1 = (Dali::Toolkit::Popup *)jarg1;
76521   {
76522     try {
76523       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76524     } catch (std::out_of_range& e) {
76525       {
76526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76527       };
76528     } catch (std::exception& e) {
76529       {
76530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76531       };
76532     } catch (...) {
76533       {
76534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76535       };
76536     }
76537   }
76538   jresult = new Dali::Actor((const Dali::Actor &)result);
76539   return jresult;
76540 }
76541
76542
76543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76544   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76545   Dali::Toolkit::Popup::DisplayState arg2 ;
76546
76547   arg1 = (Dali::Toolkit::Popup *)jarg1;
76548   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76549   {
76550     try {
76551       (arg1)->SetDisplayState(arg2);
76552     } catch (std::out_of_range& e) {
76553       {
76554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76555       };
76556     } catch (std::exception& e) {
76557       {
76558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76559       };
76560     } catch (...) {
76561       {
76562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76563       };
76564     }
76565   }
76566 }
76567
76568
76569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76570   int jresult ;
76571   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76572   Dali::Toolkit::Popup::DisplayState result;
76573
76574   arg1 = (Dali::Toolkit::Popup *)jarg1;
76575   {
76576     try {
76577       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76578     } catch (std::out_of_range& e) {
76579       {
76580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76581       };
76582     } catch (std::exception& e) {
76583       {
76584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76585       };
76586     } catch (...) {
76587       {
76588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76589       };
76590     }
76591   }
76592   jresult = (int)result;
76593   return jresult;
76594 }
76595
76596
76597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76598   void * jresult ;
76599   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76600   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76601
76602   arg1 = (Dali::Toolkit::Popup *)jarg1;
76603   {
76604     try {
76605       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76606     } catch (std::out_of_range& e) {
76607       {
76608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76609       };
76610     } catch (std::exception& e) {
76611       {
76612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76613       };
76614     } catch (...) {
76615       {
76616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76617       };
76618     }
76619   }
76620   jresult = (void *)result;
76621   return jresult;
76622 }
76623
76624
76625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76626   void * jresult ;
76627   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76628   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76629
76630   arg1 = (Dali::Toolkit::Popup *)jarg1;
76631   {
76632     try {
76633       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76634     } catch (std::out_of_range& e) {
76635       {
76636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76637       };
76638     } catch (std::exception& e) {
76639       {
76640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76641       };
76642     } catch (...) {
76643       {
76644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76645       };
76646     }
76647   }
76648   jresult = (void *)result;
76649   return jresult;
76650 }
76651
76652
76653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76654   void * jresult ;
76655   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76656   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76657
76658   arg1 = (Dali::Toolkit::Popup *)jarg1;
76659   {
76660     try {
76661       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76662     } catch (std::out_of_range& e) {
76663       {
76664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76665       };
76666     } catch (std::exception& e) {
76667       {
76668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76669       };
76670     } catch (...) {
76671       {
76672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76673       };
76674     }
76675   }
76676   jresult = (void *)result;
76677   return jresult;
76678 }
76679
76680
76681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76682   void * jresult ;
76683   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76684   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76685
76686   arg1 = (Dali::Toolkit::Popup *)jarg1;
76687   {
76688     try {
76689       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76690     } catch (std::out_of_range& e) {
76691       {
76692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76693       };
76694     } catch (std::exception& e) {
76695       {
76696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76697       };
76698     } catch (...) {
76699       {
76700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76701       };
76702     }
76703   }
76704   jresult = (void *)result;
76705   return jresult;
76706 }
76707
76708
76709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76710   void * jresult ;
76711   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76712   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76713
76714   arg1 = (Dali::Toolkit::Popup *)jarg1;
76715   {
76716     try {
76717       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76729       };
76730     }
76731   }
76732   jresult = (void *)result;
76733   return jresult;
76734 }
76735
76736
76737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76738   int jresult ;
76739   int result;
76740
76741   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76742   jresult = (int)result;
76743   return jresult;
76744 }
76745
76746
76747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76748   int jresult ;
76749   int result;
76750
76751   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76752   jresult = (int)result;
76753   return jresult;
76754 }
76755
76756
76757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76758   int jresult ;
76759   int result;
76760
76761   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76762   jresult = (int)result;
76763   return jresult;
76764 }
76765
76766
76767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76768   int jresult ;
76769   int result;
76770
76771   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76772   jresult = (int)result;
76773   return jresult;
76774 }
76775
76776
76777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76778   int jresult ;
76779   int result;
76780
76781   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76782   jresult = (int)result;
76783   return jresult;
76784 }
76785
76786
76787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76788   int jresult ;
76789   int result;
76790
76791   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76792   jresult = (int)result;
76793   return jresult;
76794 }
76795
76796
76797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76798   int jresult ;
76799   int result;
76800
76801   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76802   jresult = (int)result;
76803   return jresult;
76804 }
76805
76806
76807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76808   int jresult ;
76809   int result;
76810
76811   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76812   jresult = (int)result;
76813   return jresult;
76814 }
76815
76816
76817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76818   int jresult ;
76819   int result;
76820
76821   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76822   jresult = (int)result;
76823   return jresult;
76824 }
76825
76826
76827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76828   void * jresult ;
76829   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76830
76831   {
76832     try {
76833       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76834     } catch (std::out_of_range& e) {
76835       {
76836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76837       };
76838     } catch (std::exception& e) {
76839       {
76840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76841       };
76842     } catch (...) {
76843       {
76844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76845       };
76846     }
76847   }
76848   jresult = (void *)result;
76849   return jresult;
76850 }
76851
76852
76853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
76854   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76855
76856   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76857   {
76858     try {
76859       delete arg1;
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (...) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76871       };
76872     }
76873   }
76874 }
76875
76876
76877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76878   void * jresult ;
76879   Dali::Toolkit::ProgressBar result;
76880
76881   {
76882     try {
76883       result = Dali::Toolkit::ProgressBar::New();
76884     } catch (std::out_of_range& e) {
76885       {
76886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76887       };
76888     } catch (std::exception& e) {
76889       {
76890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76891       };
76892     } catch (...) {
76893       {
76894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76895       };
76896     }
76897   }
76898   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76899   return jresult;
76900 }
76901
76902
76903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76904   void * jresult ;
76905   Dali::Toolkit::ProgressBar *result = 0 ;
76906
76907   {
76908     try {
76909       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76910     } catch (std::out_of_range& e) {
76911       {
76912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76913       };
76914     } catch (std::exception& e) {
76915       {
76916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76917       };
76918     } catch (...) {
76919       {
76920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76921       };
76922     }
76923   }
76924   jresult = (void *)result;
76925   return jresult;
76926 }
76927
76928
76929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76930   void * jresult ;
76931   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76932   Dali::Toolkit::ProgressBar *result = 0 ;
76933
76934   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76935   if (!arg1) {
76936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76937     return 0;
76938   }
76939   {
76940     try {
76941       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76942     } catch (std::out_of_range& e) {
76943       {
76944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76945       };
76946     } catch (std::exception& e) {
76947       {
76948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76949       };
76950     } catch (...) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76953       };
76954     }
76955   }
76956   jresult = (void *)result;
76957   return jresult;
76958 }
76959
76960
76961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76962   void * jresult ;
76963   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76964   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76965   Dali::Toolkit::ProgressBar *result = 0 ;
76966
76967   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76968   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76969   if (!arg2) {
76970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76971     return 0;
76972   }
76973   {
76974     try {
76975       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
76976     } catch (std::out_of_range& e) {
76977       {
76978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76979       };
76980     } catch (std::exception& e) {
76981       {
76982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76983       };
76984     } catch (...) {
76985       {
76986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76987       };
76988     }
76989   }
76990   jresult = (void *)result;
76991   return jresult;
76992 }
76993
76994
76995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
76996   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76997
76998   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76999   {
77000     try {
77001       delete arg1;
77002     } catch (std::out_of_range& e) {
77003       {
77004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77005       };
77006     } catch (std::exception& e) {
77007       {
77008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77009       };
77010     } catch (...) {
77011       {
77012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77013       };
77014     }
77015   }
77016 }
77017
77018
77019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
77020   void * jresult ;
77021   Dali::BaseHandle arg1 ;
77022   Dali::BaseHandle *argp1 ;
77023   Dali::Toolkit::ProgressBar result;
77024
77025   argp1 = (Dali::BaseHandle *)jarg1;
77026   if (!argp1) {
77027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77028     return 0;
77029   }
77030   arg1 = *argp1;
77031   {
77032     try {
77033       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77034     } catch (std::out_of_range& e) {
77035       {
77036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77037       };
77038     } catch (std::exception& e) {
77039       {
77040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77041       };
77042     } catch (...) {
77043       {
77044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77045       };
77046     }
77047   }
77048   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77049   return jresult;
77050 }
77051
77052
77053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77054   void * jresult ;
77055   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77056   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77057
77058   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77059   {
77060     try {
77061       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77062     } catch (std::out_of_range& e) {
77063       {
77064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77065       };
77066     } catch (std::exception& e) {
77067       {
77068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77069       };
77070     } catch (...) {
77071       {
77072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77073       };
77074     }
77075   }
77076   jresult = (void *)result;
77077   return jresult;
77078 }
77079
77080
77081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77082   void * jresult ;
77083   Dali::Toolkit::GaussianBlurView *result = 0 ;
77084
77085   {
77086     try {
77087       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77088     } catch (std::out_of_range& e) {
77089       {
77090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77091       };
77092     } catch (std::exception& e) {
77093       {
77094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77095       };
77096     } catch (...) {
77097       {
77098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77099       };
77100     }
77101   }
77102   jresult = (void *)result;
77103   return jresult;
77104 }
77105
77106
77107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77108   void * jresult ;
77109   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77110   Dali::Toolkit::GaussianBlurView *result = 0 ;
77111
77112   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77113   if (!arg1) {
77114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77115     return 0;
77116   }
77117   {
77118     try {
77119       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77120     } catch (std::out_of_range& e) {
77121       {
77122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77123       };
77124     } catch (std::exception& e) {
77125       {
77126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77127       };
77128     } catch (...) {
77129       {
77130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77131       };
77132     }
77133   }
77134   jresult = (void *)result;
77135   return jresult;
77136 }
77137
77138
77139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77140   void * jresult ;
77141   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77142   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77143   Dali::Toolkit::GaussianBlurView *result = 0 ;
77144
77145   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77146   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77147   if (!arg2) {
77148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77149     return 0;
77150   }
77151   {
77152     try {
77153       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77154     } catch (std::out_of_range& e) {
77155       {
77156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77157       };
77158     } catch (std::exception& e) {
77159       {
77160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77161       };
77162     } catch (...) {
77163       {
77164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77165       };
77166     }
77167   }
77168   jresult = (void *)result;
77169   return jresult;
77170 }
77171
77172
77173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77174   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77175
77176   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77177   {
77178     try {
77179       delete arg1;
77180     } catch (std::out_of_range& e) {
77181       {
77182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77183       };
77184     } catch (std::exception& e) {
77185       {
77186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77187       };
77188     } catch (...) {
77189       {
77190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77191       };
77192     }
77193   }
77194 }
77195
77196
77197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77198   void * jresult ;
77199   Dali::BaseHandle arg1 ;
77200   Dali::BaseHandle *argp1 ;
77201   Dali::Toolkit::GaussianBlurView result;
77202
77203   argp1 = (Dali::BaseHandle *)jarg1;
77204   if (!argp1) {
77205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77206     return 0;
77207   }
77208   arg1 = *argp1;
77209   {
77210     try {
77211       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77212     } catch (std::out_of_range& e) {
77213       {
77214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77215       };
77216     } catch (std::exception& e) {
77217       {
77218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77219       };
77220     } catch (...) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77223       };
77224     }
77225   }
77226   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77227   return jresult;
77228 }
77229
77230
77231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77232   void * jresult ;
77233   Dali::Toolkit::GaussianBlurView result;
77234
77235   {
77236     try {
77237       result = Dali::Toolkit::GaussianBlurView::New();
77238     } catch (std::out_of_range& e) {
77239       {
77240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77241       };
77242     } catch (std::exception& e) {
77243       {
77244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77245       };
77246     } catch (...) {
77247       {
77248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77249       };
77250     }
77251   }
77252   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77253   return jresult;
77254 }
77255
77256
77257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77258   void * jresult ;
77259   unsigned int arg1 ;
77260   float arg2 ;
77261   Dali::Pixel::Format arg3 ;
77262   float arg4 ;
77263   float arg5 ;
77264   bool arg6 ;
77265   Dali::Toolkit::GaussianBlurView result;
77266
77267   arg1 = (unsigned int)jarg1;
77268   arg2 = (float)jarg2;
77269   arg3 = (Dali::Pixel::Format)jarg3;
77270   arg4 = (float)jarg4;
77271   arg5 = (float)jarg5;
77272   arg6 = jarg6 ? true : false;
77273   {
77274     try {
77275       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77276     } catch (std::out_of_range& e) {
77277       {
77278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77279       };
77280     } catch (std::exception& e) {
77281       {
77282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77287       };
77288     }
77289   }
77290   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77291   return jresult;
77292 }
77293
77294
77295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77296   void * jresult ;
77297   unsigned int arg1 ;
77298   float arg2 ;
77299   Dali::Pixel::Format arg3 ;
77300   float arg4 ;
77301   float arg5 ;
77302   Dali::Toolkit::GaussianBlurView result;
77303
77304   arg1 = (unsigned int)jarg1;
77305   arg2 = (float)jarg2;
77306   arg3 = (Dali::Pixel::Format)jarg3;
77307   arg4 = (float)jarg4;
77308   arg5 = (float)jarg5;
77309   {
77310     try {
77311       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77312     } catch (std::out_of_range& e) {
77313       {
77314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77315       };
77316     } catch (std::exception& e) {
77317       {
77318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77319       };
77320     } catch (...) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77323       };
77324     }
77325   }
77326   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77327   return jresult;
77328 }
77329
77330
77331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77332   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77333   Dali::Actor arg2 ;
77334   Dali::Actor *argp2 ;
77335
77336   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77337   argp2 = (Dali::Actor *)jarg2;
77338   if (!argp2) {
77339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77340     return ;
77341   }
77342   arg2 = *argp2;
77343   {
77344     try {
77345       (arg1)->Add(arg2);
77346     } catch (std::out_of_range& e) {
77347       {
77348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77349       };
77350     } catch (std::exception& e) {
77351       {
77352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77353       };
77354     } catch (...) {
77355       {
77356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77357       };
77358     }
77359   }
77360 }
77361
77362
77363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77364   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77365   Dali::Actor arg2 ;
77366   Dali::Actor *argp2 ;
77367
77368   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77369   argp2 = (Dali::Actor *)jarg2;
77370   if (!argp2) {
77371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77372     return ;
77373   }
77374   arg2 = *argp2;
77375   {
77376     try {
77377       (arg1)->Remove(arg2);
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_Activate(void * jarg1) {
77396   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77397
77398   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77399   {
77400     try {
77401       (arg1)->Activate();
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_ActivateOnce(void * jarg1) {
77420   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77421
77422   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77423   {
77424     try {
77425       (arg1)->ActivateOnce();
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_Deactivate(void * jarg1) {
77444   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77445
77446   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77447   {
77448     try {
77449       (arg1)->Deactivate();
77450     } catch (std::out_of_range& e) {
77451       {
77452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77453       };
77454     } catch (std::exception& e) {
77455       {
77456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77457       };
77458     } catch (...) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77461       };
77462     }
77463   }
77464 }
77465
77466
77467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77468   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77469   Dali::Image arg2 ;
77470   Dali::FrameBufferImage arg3 ;
77471   Dali::Image *argp2 ;
77472   Dali::FrameBufferImage *argp3 ;
77473
77474   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77475   argp2 = (Dali::Image *)jarg2;
77476   if (!argp2) {
77477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77478     return ;
77479   }
77480   arg2 = *argp2;
77481   argp3 = (Dali::FrameBufferImage *)jarg3;
77482   if (!argp3) {
77483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77484     return ;
77485   }
77486   arg3 = *argp3;
77487   {
77488     try {
77489       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77490     } catch (std::out_of_range& e) {
77491       {
77492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77493       };
77494     } catch (std::exception& e) {
77495       {
77496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77497       };
77498     } catch (...) {
77499       {
77500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77501       };
77502     }
77503   }
77504 }
77505
77506
77507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77508   int jresult ;
77509   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77510   Dali::Property::Index result;
77511
77512   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77513   {
77514     try {
77515       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77516     } catch (std::out_of_range& e) {
77517       {
77518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77519       };
77520     } catch (std::exception& e) {
77521       {
77522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77523       };
77524     } catch (...) {
77525       {
77526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77527       };
77528     }
77529   }
77530   jresult = result;
77531   return jresult;
77532 }
77533
77534
77535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77536   void * jresult ;
77537   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77538   Dali::FrameBufferImage result;
77539
77540   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77541   {
77542     try {
77543       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77544     } catch (std::out_of_range& e) {
77545       {
77546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77547       };
77548     } catch (std::exception& e) {
77549       {
77550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77551       };
77552     } catch (...) {
77553       {
77554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77555       };
77556     }
77557   }
77558   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77559   return jresult;
77560 }
77561
77562
77563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77564   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77565   Dali::Vector4 *arg2 = 0 ;
77566
77567   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77568   arg2 = (Dali::Vector4 *)jarg2;
77569   if (!arg2) {
77570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77571     return ;
77572   }
77573   {
77574     try {
77575       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77576     } catch (std::out_of_range& e) {
77577       {
77578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77579       };
77580     } catch (std::exception& e) {
77581       {
77582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77583       };
77584     } catch (...) {
77585       {
77586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77587       };
77588     }
77589   }
77590 }
77591
77592
77593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77594   void * jresult ;
77595   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77596   Dali::Vector4 result;
77597
77598   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77599   {
77600     try {
77601       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77602     } catch (std::out_of_range& e) {
77603       {
77604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77605       };
77606     } catch (std::exception& e) {
77607       {
77608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77609       };
77610     } catch (...) {
77611       {
77612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77613       };
77614     }
77615   }
77616   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77617   return jresult;
77618 }
77619
77620
77621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77622   void * jresult ;
77623   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77624   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77625
77626   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77627   {
77628     try {
77629       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77630     } catch (std::out_of_range& e) {
77631       {
77632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77633       };
77634     } catch (std::exception& e) {
77635       {
77636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77637       };
77638     } catch (...) {
77639       {
77640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77641       };
77642     }
77643   }
77644   jresult = (void *)result;
77645   return jresult;
77646 }
77647
77648
77649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77650   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77651
77652   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77653   {
77654     try {
77655       delete arg1;
77656     } catch (std::out_of_range& e) {
77657       {
77658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77659       };
77660     } catch (std::exception& e) {
77661       {
77662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77663       };
77664     } catch (...) {
77665       {
77666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77667       };
77668     }
77669   }
77670 }
77671
77672
77673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77674   unsigned int jresult ;
77675   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77676   unsigned int result;
77677
77678   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77679   {
77680     try {
77681       result = (unsigned int)(arg1)->GetNumberOfPages();
77682     } catch (std::out_of_range& e) {
77683       {
77684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77685       };
77686     } catch (std::exception& e) {
77687       {
77688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77689       };
77690     } catch (...) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77693       };
77694     }
77695   }
77696   jresult = result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77702   void * jresult ;
77703   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77704   unsigned int arg2 ;
77705   Dali::Texture result;
77706
77707   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77708   arg2 = (unsigned int)jarg2;
77709   {
77710     try {
77711       result = (arg1)->NewPage(arg2);
77712     } catch (std::out_of_range& e) {
77713       {
77714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77715       };
77716     } catch (std::exception& e) {
77717       {
77718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (...) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77723       };
77724     }
77725   }
77726   jresult = new Dali::Texture((const Dali::Texture &)result);
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77732   int jresult ;
77733   int result;
77734
77735   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77736   jresult = (int)result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77742   int jresult ;
77743   int result;
77744
77745   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77746   jresult = (int)result;
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77752   int jresult ;
77753   int result;
77754
77755   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77756   jresult = (int)result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77762   void * jresult ;
77763   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77764
77765   {
77766     try {
77767       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77768     } catch (std::out_of_range& e) {
77769       {
77770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77771       };
77772     } catch (std::exception& e) {
77773       {
77774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77775       };
77776     } catch (...) {
77777       {
77778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77779       };
77780     }
77781   }
77782   jresult = (void *)result;
77783   return jresult;
77784 }
77785
77786
77787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77788   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77789
77790   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77791   {
77792     try {
77793       delete arg1;
77794     } catch (std::out_of_range& e) {
77795       {
77796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77797       };
77798     } catch (std::exception& e) {
77799       {
77800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77801       };
77802     } catch (...) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77805       };
77806     }
77807   }
77808 }
77809
77810
77811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77812   void * jresult ;
77813   Dali::Toolkit::PageTurnView *result = 0 ;
77814
77815   {
77816     try {
77817       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77818     } catch (std::out_of_range& e) {
77819       {
77820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77821       };
77822     } catch (std::exception& e) {
77823       {
77824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77825       };
77826     } catch (...) {
77827       {
77828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77829       };
77830     }
77831   }
77832   jresult = (void *)result;
77833   return jresult;
77834 }
77835
77836
77837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77838   void * jresult ;
77839   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77840   Dali::Toolkit::PageTurnView *result = 0 ;
77841
77842   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77843   if (!arg1) {
77844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77845     return 0;
77846   }
77847   {
77848     try {
77849       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77850     } catch (std::out_of_range& e) {
77851       {
77852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77853       };
77854     } catch (std::exception& e) {
77855       {
77856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77857       };
77858     } catch (...) {
77859       {
77860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77861       };
77862     }
77863   }
77864   jresult = (void *)result;
77865   return jresult;
77866 }
77867
77868
77869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77870   void * jresult ;
77871   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77872   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77873   Dali::Toolkit::PageTurnView *result = 0 ;
77874
77875   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77876   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77877   if (!arg2) {
77878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77879     return 0;
77880   }
77881   {
77882     try {
77883       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77884     } catch (std::out_of_range& e) {
77885       {
77886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77887       };
77888     } catch (std::exception& e) {
77889       {
77890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77891       };
77892     } catch (...) {
77893       {
77894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77895       };
77896     }
77897   }
77898   jresult = (void *)result;
77899   return jresult;
77900 }
77901
77902
77903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77904   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77905
77906   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77907   {
77908     try {
77909       delete arg1;
77910     } catch (std::out_of_range& e) {
77911       {
77912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77913       };
77914     } catch (std::exception& e) {
77915       {
77916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77917       };
77918     } catch (...) {
77919       {
77920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77921       };
77922     }
77923   }
77924 }
77925
77926
77927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77928   void * jresult ;
77929   Dali::BaseHandle arg1 ;
77930   Dali::BaseHandle *argp1 ;
77931   Dali::Toolkit::PageTurnView result;
77932
77933   argp1 = (Dali::BaseHandle *)jarg1;
77934   if (!argp1) {
77935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77936     return 0;
77937   }
77938   arg1 = *argp1;
77939   {
77940     try {
77941       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
77942     } catch (std::out_of_range& e) {
77943       {
77944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77945       };
77946     } catch (std::exception& e) {
77947       {
77948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77949       };
77950     } catch (...) {
77951       {
77952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77953       };
77954     }
77955   }
77956   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77957   return jresult;
77958 }
77959
77960
77961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77962   void * jresult ;
77963   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77964   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77965
77966   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77967   {
77968     try {
77969       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77970     } catch (std::out_of_range& e) {
77971       {
77972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77973       };
77974     } catch (std::exception& e) {
77975       {
77976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77977       };
77978     } catch (...) {
77979       {
77980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77981       };
77982     }
77983   }
77984   jresult = (void *)result;
77985   return jresult;
77986 }
77987
77988
77989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
77990   void * jresult ;
77991   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77992   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77993
77994   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77995   {
77996     try {
77997       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
77998     } catch (std::out_of_range& e) {
77999       {
78000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78001       };
78002     } catch (std::exception& e) {
78003       {
78004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78005       };
78006     } catch (...) {
78007       {
78008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78009       };
78010     }
78011   }
78012   jresult = (void *)result;
78013   return jresult;
78014 }
78015
78016
78017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
78018   void * jresult ;
78019   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78020   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78021
78022   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78023   {
78024     try {
78025       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78026     } catch (std::out_of_range& e) {
78027       {
78028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78029       };
78030     } catch (std::exception& e) {
78031       {
78032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78033       };
78034     } catch (...) {
78035       {
78036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78037       };
78038     }
78039   }
78040   jresult = (void *)result;
78041   return jresult;
78042 }
78043
78044
78045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78046   void * jresult ;
78047   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78048   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78049
78050   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78051   {
78052     try {
78053       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78054     } catch (std::out_of_range& e) {
78055       {
78056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78057       };
78058     } catch (std::exception& e) {
78059       {
78060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78061       };
78062     } catch (...) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78065       };
78066     }
78067   }
78068   jresult = (void *)result;
78069   return jresult;
78070 }
78071
78072
78073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78074   void * jresult ;
78075   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78076
78077   {
78078     try {
78079       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78080     } catch (std::out_of_range& e) {
78081       {
78082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78083       };
78084     } catch (std::exception& e) {
78085       {
78086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78087       };
78088     } catch (...) {
78089       {
78090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78091       };
78092     }
78093   }
78094   jresult = (void *)result;
78095   return jresult;
78096 }
78097
78098
78099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78100   void * jresult ;
78101   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78102   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78103
78104   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78105   if (!arg1) {
78106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78107     return 0;
78108   }
78109   {
78110     try {
78111       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78112     } catch (std::out_of_range& e) {
78113       {
78114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78115       };
78116     } catch (std::exception& e) {
78117       {
78118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78119       };
78120     } catch (...) {
78121       {
78122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78123       };
78124     }
78125   }
78126   jresult = (void *)result;
78127   return jresult;
78128 }
78129
78130
78131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78132   void * jresult ;
78133   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78134   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78135   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78136
78137   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78138   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78139   if (!arg2) {
78140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78141     return 0;
78142   }
78143   {
78144     try {
78145       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78146     } catch (std::out_of_range& e) {
78147       {
78148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78149       };
78150     } catch (std::exception& e) {
78151       {
78152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78153       };
78154     } catch (...) {
78155       {
78156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78157       };
78158     }
78159   }
78160   jresult = (void *)result;
78161   return jresult;
78162 }
78163
78164
78165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78166   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78167
78168   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78169   {
78170     try {
78171       delete arg1;
78172     } catch (std::out_of_range& e) {
78173       {
78174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78175       };
78176     } catch (std::exception& e) {
78177       {
78178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78179       };
78180     } catch (...) {
78181       {
78182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78183       };
78184     }
78185   }
78186 }
78187
78188
78189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78190   void * jresult ;
78191   Dali::Toolkit::PageFactory *arg1 = 0 ;
78192   Dali::Vector2 *arg2 = 0 ;
78193   Dali::Toolkit::PageTurnLandscapeView result;
78194
78195   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78196   if (!arg1) {
78197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78198     return 0;
78199   }
78200   arg2 = (Dali::Vector2 *)jarg2;
78201   if (!arg2) {
78202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78203     return 0;
78204   }
78205   {
78206     try {
78207       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78208     } catch (std::out_of_range& e) {
78209       {
78210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78211       };
78212     } catch (std::exception& e) {
78213       {
78214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (...) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78219       };
78220     }
78221   }
78222   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78223   return jresult;
78224 }
78225
78226
78227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78228   void * jresult ;
78229   Dali::BaseHandle arg1 ;
78230   Dali::BaseHandle *argp1 ;
78231   Dali::Toolkit::PageTurnLandscapeView result;
78232
78233   argp1 = (Dali::BaseHandle *)jarg1;
78234   if (!argp1) {
78235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78236     return 0;
78237   }
78238   arg1 = *argp1;
78239   {
78240     try {
78241       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78242     } catch (std::out_of_range& e) {
78243       {
78244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78245       };
78246     } catch (std::exception& e) {
78247       {
78248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78249       };
78250     } catch (...) {
78251       {
78252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78253       };
78254     }
78255   }
78256   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78257   return jresult;
78258 }
78259
78260
78261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78262   void * jresult ;
78263   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78264
78265   {
78266     try {
78267       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78268     } catch (std::out_of_range& e) {
78269       {
78270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78271       };
78272     } catch (std::exception& e) {
78273       {
78274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78275       };
78276     } catch (...) {
78277       {
78278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78279       };
78280     }
78281   }
78282   jresult = (void *)result;
78283   return jresult;
78284 }
78285
78286
78287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78288   void * jresult ;
78289   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78290   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78291
78292   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78293   if (!arg1) {
78294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78295     return 0;
78296   }
78297   {
78298     try {
78299       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78300     } catch (std::out_of_range& e) {
78301       {
78302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78303       };
78304     } catch (std::exception& e) {
78305       {
78306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78307       };
78308     } catch (...) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78311       };
78312     }
78313   }
78314   jresult = (void *)result;
78315   return jresult;
78316 }
78317
78318
78319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78320   void * jresult ;
78321   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78322   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78323   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78324
78325   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78326   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78327   if (!arg2) {
78328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78329     return 0;
78330   }
78331   {
78332     try {
78333       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78334     } catch (std::out_of_range& e) {
78335       {
78336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78337       };
78338     } catch (std::exception& e) {
78339       {
78340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78341       };
78342     } catch (...) {
78343       {
78344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78345       };
78346     }
78347   }
78348   jresult = (void *)result;
78349   return jresult;
78350 }
78351
78352
78353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78354   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78355
78356   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78357   {
78358     try {
78359       delete arg1;
78360     } catch (std::out_of_range& e) {
78361       {
78362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78363       };
78364     } catch (std::exception& e) {
78365       {
78366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78367       };
78368     } catch (...) {
78369       {
78370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78371       };
78372     }
78373   }
78374 }
78375
78376
78377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78378   void * jresult ;
78379   Dali::Toolkit::PageFactory *arg1 = 0 ;
78380   Dali::Vector2 *arg2 = 0 ;
78381   Dali::Toolkit::PageTurnPortraitView result;
78382
78383   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78384   if (!arg1) {
78385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78386     return 0;
78387   }
78388   arg2 = (Dali::Vector2 *)jarg2;
78389   if (!arg2) {
78390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78391     return 0;
78392   }
78393   {
78394     try {
78395       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78396     } catch (std::out_of_range& e) {
78397       {
78398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78399       };
78400     } catch (std::exception& e) {
78401       {
78402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78403       };
78404     } catch (...) {
78405       {
78406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78407       };
78408     }
78409   }
78410   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78411   return jresult;
78412 }
78413
78414
78415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78416   void * jresult ;
78417   Dali::BaseHandle arg1 ;
78418   Dali::BaseHandle *argp1 ;
78419   Dali::Toolkit::PageTurnPortraitView result;
78420
78421   argp1 = (Dali::BaseHandle *)jarg1;
78422   if (!argp1) {
78423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78424     return 0;
78425   }
78426   arg1 = *argp1;
78427   {
78428     try {
78429       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78430     } catch (std::out_of_range& e) {
78431       {
78432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78433       };
78434     } catch (std::exception& e) {
78435       {
78436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78437       };
78438     } catch (...) {
78439       {
78440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78441       };
78442     }
78443   }
78444   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78445   return jresult;
78446 }
78447
78448
78449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78450   int jresult ;
78451   int result;
78452
78453   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78454   jresult = (int)result;
78455   return jresult;
78456 }
78457
78458
78459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78460   int jresult ;
78461   int result;
78462
78463   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78464   jresult = (int)result;
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78470   int jresult ;
78471   int result;
78472
78473   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78474   jresult = (int)result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78480   void * jresult ;
78481   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78482
78483   {
78484     try {
78485       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78486     } catch (std::out_of_range& e) {
78487       {
78488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78489       };
78490     } catch (std::exception& e) {
78491       {
78492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78493       };
78494     } catch (...) {
78495       {
78496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78497       };
78498     }
78499   }
78500   jresult = (void *)result;
78501   return jresult;
78502 }
78503
78504
78505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78506   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78507
78508   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78509   {
78510     try {
78511       delete arg1;
78512     } catch (std::out_of_range& e) {
78513       {
78514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78515       };
78516     } catch (std::exception& e) {
78517       {
78518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78519       };
78520     } catch (...) {
78521       {
78522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78523       };
78524     }
78525   }
78526 }
78527
78528
78529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78530   void * jresult ;
78531   Dali::Toolkit::ToggleButton *result = 0 ;
78532
78533   {
78534     try {
78535       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78536     } catch (std::out_of_range& e) {
78537       {
78538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78539       };
78540     } catch (std::exception& e) {
78541       {
78542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78543       };
78544     } catch (...) {
78545       {
78546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78547       };
78548     }
78549   }
78550   jresult = (void *)result;
78551   return jresult;
78552 }
78553
78554
78555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78556   void * jresult ;
78557   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78558   Dali::Toolkit::ToggleButton *result = 0 ;
78559
78560   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78561   if (!arg1) {
78562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78563     return 0;
78564   }
78565   {
78566     try {
78567       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78568     } catch (std::out_of_range& e) {
78569       {
78570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78571       };
78572     } catch (std::exception& e) {
78573       {
78574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78575       };
78576     } catch (...) {
78577       {
78578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78579       };
78580     }
78581   }
78582   jresult = (void *)result;
78583   return jresult;
78584 }
78585
78586
78587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78588   void * jresult ;
78589   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78590   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78591   Dali::Toolkit::ToggleButton *result = 0 ;
78592
78593   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78594   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78595   if (!arg2) {
78596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78597     return 0;
78598   }
78599   {
78600     try {
78601       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78602     } catch (std::out_of_range& e) {
78603       {
78604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78605       };
78606     } catch (std::exception& e) {
78607       {
78608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78609       };
78610     } catch (...) {
78611       {
78612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78613       };
78614     }
78615   }
78616   jresult = (void *)result;
78617   return jresult;
78618 }
78619
78620
78621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78622   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78623
78624   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78625   {
78626     try {
78627       delete arg1;
78628     } catch (std::out_of_range& e) {
78629       {
78630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78631       };
78632     } catch (std::exception& e) {
78633       {
78634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78635       };
78636     } catch (...) {
78637       {
78638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78639       };
78640     }
78641   }
78642 }
78643
78644
78645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78646   void * jresult ;
78647   Dali::Toolkit::ToggleButton result;
78648
78649   {
78650     try {
78651       result = Dali::Toolkit::ToggleButton::New();
78652     } catch (std::out_of_range& e) {
78653       {
78654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78655       };
78656     } catch (std::exception& e) {
78657       {
78658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78659       };
78660     } catch (...) {
78661       {
78662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78663       };
78664     }
78665   }
78666   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78672   void * jresult ;
78673   Dali::BaseHandle arg1 ;
78674   Dali::BaseHandle *argp1 ;
78675   Dali::Toolkit::ToggleButton result;
78676
78677   argp1 = (Dali::BaseHandle *)jarg1;
78678   if (!argp1) {
78679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78680     return 0;
78681   }
78682   arg1 = *argp1;
78683   {
78684     try {
78685       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78686     } catch (std::out_of_range& e) {
78687       {
78688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (std::exception& e) {
78691       {
78692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (...) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78697       };
78698     }
78699   }
78700   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78701   return jresult;
78702 }
78703
78704
78705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78706   void * jresult ;
78707   Dali::Toolkit::Visual::Base *result = 0 ;
78708
78709   {
78710     try {
78711       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78712     } catch (std::out_of_range& e) {
78713       {
78714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78715       };
78716     } catch (std::exception& e) {
78717       {
78718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78719       };
78720     } catch (...) {
78721       {
78722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78723       };
78724     }
78725   }
78726   jresult = (void *)result;
78727   return jresult;
78728 }
78729
78730
78731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78732   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78733
78734   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78735   {
78736     try {
78737       delete arg1;
78738     } catch (std::out_of_range& e) {
78739       {
78740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78741       };
78742     } catch (std::exception& e) {
78743       {
78744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78745       };
78746     } catch (...) {
78747       {
78748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78749       };
78750     }
78751   }
78752 }
78753
78754
78755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78756   void * jresult ;
78757   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78758   Dali::Toolkit::Visual::Base *result = 0 ;
78759
78760   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78761   if (!arg1) {
78762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78763     return 0;
78764   }
78765   {
78766     try {
78767       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78768     } catch (std::out_of_range& e) {
78769       {
78770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78771       };
78772     } catch (std::exception& e) {
78773       {
78774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78775       };
78776     } catch (...) {
78777       {
78778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78779       };
78780     }
78781   }
78782   jresult = (void *)result;
78783   return jresult;
78784 }
78785
78786
78787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78788   void * jresult ;
78789   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78790   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78791   Dali::Toolkit::Visual::Base *result = 0 ;
78792
78793   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78794   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78795   if (!arg2) {
78796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78797     return 0;
78798   }
78799   {
78800     try {
78801       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78802     } catch (std::out_of_range& e) {
78803       {
78804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78805       };
78806     } catch (std::exception& e) {
78807       {
78808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78809       };
78810     } catch (...) {
78811       {
78812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78813       };
78814     }
78815   }
78816   jresult = (void *)result;
78817   return jresult;
78818 }
78819
78820
78821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78822   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78823   std::string *arg2 = 0 ;
78824
78825   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78826   if (!jarg2) {
78827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78828     return ;
78829   }
78830   std::string arg2_str(jarg2);
78831   arg2 = &arg2_str;
78832   {
78833     try {
78834       (arg1)->SetName((std::string const &)*arg2);
78835     } catch (std::out_of_range& e) {
78836       {
78837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78838       };
78839     } catch (std::exception& e) {
78840       {
78841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78842       };
78843     } catch (...) {
78844       {
78845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78846       };
78847     }
78848   }
78849
78850   //argout typemap for const std::string&
78851
78852 }
78853
78854
78855 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78856   char * jresult ;
78857   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78858   std::string *result = 0 ;
78859
78860   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78861   {
78862     try {
78863       result = (std::string *) &(arg1)->GetName();
78864     } catch (std::out_of_range& e) {
78865       {
78866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78867       };
78868     } catch (std::exception& e) {
78869       {
78870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78871       };
78872     } catch (...) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78875       };
78876     }
78877   }
78878   jresult = SWIG_csharp_string_callback(result->c_str());
78879   return jresult;
78880 }
78881
78882
78883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78884   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78885   Dali::Property::Map *arg2 = 0 ;
78886   Dali::Size arg3 ;
78887   Dali::Size *argp3 ;
78888
78889   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78890   arg2 = (Dali::Property::Map *)jarg2;
78891   if (!arg2) {
78892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78893     return ;
78894   }
78895   argp3 = (Dali::Size *)jarg3;
78896   if (!argp3) {
78897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78898     return ;
78899   }
78900   arg3 = *argp3;
78901   {
78902     try {
78903       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78904     } catch (std::out_of_range& e) {
78905       {
78906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78907       };
78908     } catch (std::exception& e) {
78909       {
78910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78911       };
78912     } catch (...) {
78913       {
78914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78915       };
78916     }
78917   }
78918 }
78919
78920
78921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78922   float jresult ;
78923   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78924   float arg2 ;
78925   float result;
78926
78927   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78928   arg2 = (float)jarg2;
78929   {
78930     try {
78931       result = (float)(arg1)->GetHeightForWidth(arg2);
78932     } catch (std::out_of_range& e) {
78933       {
78934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78935       };
78936     } catch (std::exception& e) {
78937       {
78938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78939       };
78940     } catch (...) {
78941       {
78942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78943       };
78944     }
78945   }
78946   jresult = result;
78947   return jresult;
78948 }
78949
78950
78951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78952   float jresult ;
78953   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78954   float arg2 ;
78955   float result;
78956
78957   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78958   arg2 = (float)jarg2;
78959   {
78960     try {
78961       result = (float)(arg1)->GetWidthForHeight(arg2);
78962     } catch (std::out_of_range& e) {
78963       {
78964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (std::exception& e) {
78967       {
78968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78969       };
78970     } catch (...) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78973       };
78974     }
78975   }
78976   jresult = result;
78977   return jresult;
78978 }
78979
78980
78981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
78982   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78983   Dali::Vector2 *arg2 = 0 ;
78984
78985   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78986   arg2 = (Dali::Vector2 *)jarg2;
78987   if (!arg2) {
78988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
78989     return ;
78990   }
78991   {
78992     try {
78993       (arg1)->GetNaturalSize(*arg2);
78994     } catch (std::out_of_range& e) {
78995       {
78996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78997       };
78998     } catch (std::exception& e) {
78999       {
79000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79001       };
79002     } catch (...) {
79003       {
79004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79005       };
79006     }
79007   }
79008 }
79009
79010
79011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
79012   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79013   float arg2 ;
79014
79015   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79016   arg2 = (int)jarg2;
79017   {
79018     try {
79019       (arg1)->SetDepthIndex(arg2);
79020     } catch (std::out_of_range& e) {
79021       {
79022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79023       };
79024     } catch (std::exception& e) {
79025       {
79026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79027       };
79028     } catch (...) {
79029       {
79030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79031       };
79032     }
79033   }
79034 }
79035
79036
79037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79038   int jresult ;
79039   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79040   int result;
79041
79042   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79043   {
79044     try {
79045       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79046     } catch (std::out_of_range& e) {
79047       {
79048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (std::exception& e) {
79051       {
79052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79053       };
79054     } catch (...) {
79055       {
79056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79057       };
79058     }
79059   }
79060   jresult = result;
79061   return jresult;
79062 }
79063
79064
79065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79066   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79067   Dali::Property::Map *arg2 = 0 ;
79068
79069   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79070   arg2 = (Dali::Property::Map *)jarg2;
79071   if (!arg2) {
79072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79073     return ;
79074   }
79075   {
79076     try {
79077       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79078     } catch (std::out_of_range& e) {
79079       {
79080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79081       };
79082     } catch (std::exception& e) {
79083       {
79084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79085       };
79086     } catch (...) {
79087       {
79088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79089       };
79090     }
79091   }
79092 }
79093
79094
79095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79096   void * jresult ;
79097   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79098   Dali::Toolkit::Visual::Base *result = 0 ;
79099
79100   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79101   {
79102     try {
79103       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79104     } catch (std::out_of_range& e) {
79105       {
79106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79107       };
79108     } catch (std::exception& e) {
79109       {
79110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79111       };
79112     } catch (...) {
79113       {
79114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79115       };
79116     }
79117   }
79118   jresult = (void *)result;
79119   return jresult;
79120 }
79121
79122
79123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79124   void * jresult ;
79125   Dali::Toolkit::VisualFactory result;
79126
79127   {
79128     try {
79129       result = Dali::Toolkit::VisualFactory::Get();
79130     } catch (std::out_of_range& e) {
79131       {
79132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79133       };
79134     } catch (std::exception& e) {
79135       {
79136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79137       };
79138     } catch (...) {
79139       {
79140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79141       };
79142     }
79143   }
79144   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79145   return jresult;
79146 }
79147
79148
79149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79150   void * jresult ;
79151   Dali::Toolkit::VisualFactory *result = 0 ;
79152
79153   {
79154     try {
79155       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79156     } catch (std::out_of_range& e) {
79157       {
79158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79159       };
79160     } catch (std::exception& e) {
79161       {
79162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79163       };
79164     } catch (...) {
79165       {
79166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79167       };
79168     }
79169   }
79170   jresult = (void *)result;
79171   return jresult;
79172 }
79173
79174
79175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79176   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79177
79178   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79179   {
79180     try {
79181       delete arg1;
79182     } catch (std::out_of_range& e) {
79183       {
79184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79185       };
79186     } catch (std::exception& e) {
79187       {
79188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79189       };
79190     } catch (...) {
79191       {
79192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79193       };
79194     }
79195   }
79196 }
79197
79198
79199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79200   void * jresult ;
79201   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79202   Dali::Toolkit::VisualFactory *result = 0 ;
79203
79204   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79205   if (!arg1) {
79206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79207     return 0;
79208   }
79209   {
79210     try {
79211       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79212     } catch (std::out_of_range& e) {
79213       {
79214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79215       };
79216     } catch (std::exception& e) {
79217       {
79218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79219       };
79220     } catch (...) {
79221       {
79222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79223       };
79224     }
79225   }
79226   jresult = (void *)result;
79227   return jresult;
79228 }
79229
79230
79231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79232   void * jresult ;
79233   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79234   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79235   Dali::Toolkit::VisualFactory *result = 0 ;
79236
79237   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79238   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79239   if (!arg2) {
79240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79241     return 0;
79242   }
79243   {
79244     try {
79245       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79246     } catch (std::out_of_range& e) {
79247       {
79248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79249       };
79250     } catch (std::exception& e) {
79251       {
79252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79253       };
79254     } catch (...) {
79255       {
79256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79257       };
79258     }
79259   }
79260   jresult = (void *)result;
79261   return jresult;
79262 }
79263
79264
79265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79266   void * jresult ;
79267   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79268   Dali::Property::Map *arg2 = 0 ;
79269   Dali::Toolkit::Visual::Base result;
79270
79271   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79272   arg2 = (Dali::Property::Map *)jarg2;
79273   if (!arg2) {
79274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79275     return 0;
79276   }
79277   {
79278     try {
79279       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79280     } catch (std::out_of_range& e) {
79281       {
79282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79283       };
79284     } catch (std::exception& e) {
79285       {
79286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79287       };
79288     } catch (...) {
79289       {
79290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79291       };
79292     }
79293   }
79294   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79295   return jresult;
79296 }
79297
79298
79299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79300   void * jresult ;
79301   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79302   Dali::Image *arg2 = 0 ;
79303   Dali::Toolkit::Visual::Base result;
79304
79305   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79306   arg2 = (Dali::Image *)jarg2;
79307   if (!arg2) {
79308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79309     return 0;
79310   }
79311   {
79312     try {
79313       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79314     } catch (std::out_of_range& e) {
79315       {
79316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79317       };
79318     } catch (std::exception& e) {
79319       {
79320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79321       };
79322     } catch (...) {
79323       {
79324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79325       };
79326     }
79327   }
79328   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79329   return jresult;
79330 }
79331
79332
79333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79334   void * jresult ;
79335   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79336   std::string *arg2 = 0 ;
79337   Dali::ImageDimensions arg3 ;
79338   Dali::ImageDimensions *argp3 ;
79339   Dali::Toolkit::Visual::Base result;
79340
79341   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79342   if (!jarg2) {
79343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79344     return 0;
79345   }
79346   std::string arg2_str(jarg2);
79347   arg2 = &arg2_str;
79348   argp3 = (Dali::ImageDimensions *)jarg3;
79349   if (!argp3) {
79350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79351     return 0;
79352   }
79353   arg3 = *argp3;
79354   {
79355     try {
79356       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79357     } catch (std::out_of_range& e) {
79358       {
79359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79360       };
79361     } catch (std::exception& e) {
79362       {
79363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79364       };
79365     } catch (...) {
79366       {
79367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79368       };
79369     }
79370   }
79371   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79372
79373   //argout typemap for const std::string&
79374
79375   return jresult;
79376 }
79377
79378
79379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79380   void * jresult ;
79381   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79382
79383   {
79384     try {
79385       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79386     } catch (std::out_of_range& e) {
79387       {
79388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79389       };
79390     } catch (std::exception& e) {
79391       {
79392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79393       };
79394     } catch (...) {
79395       {
79396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79397       };
79398     }
79399   }
79400   jresult = (void *)result;
79401   return jresult;
79402 }
79403
79404
79405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79406   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79407
79408   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79409   {
79410     try {
79411       delete arg1;
79412     } catch (std::out_of_range& e) {
79413       {
79414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79415       };
79416     } catch (std::exception& e) {
79417       {
79418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79419       };
79420     } catch (...) {
79421       {
79422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79423       };
79424     }
79425   }
79426 }
79427
79428
79429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79430   void * jresult ;
79431   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79432   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79433
79434   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79435   if (!arg1) {
79436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79437     return 0;
79438   }
79439   {
79440     try {
79441       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79442     } catch (std::out_of_range& e) {
79443       {
79444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79445       };
79446     } catch (std::exception& e) {
79447       {
79448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79449       };
79450     } catch (...) {
79451       {
79452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79453       };
79454     }
79455   }
79456   jresult = (void *)result;
79457   return jresult;
79458 }
79459
79460
79461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79462   void * jresult ;
79463   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79464   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79465   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79466
79467   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79468   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79469   if (!arg2) {
79470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79471     return 0;
79472   }
79473   {
79474     try {
79475       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79476     } catch (std::out_of_range& e) {
79477       {
79478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79479       };
79480     } catch (std::exception& e) {
79481       {
79482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79483       };
79484     } catch (...) {
79485       {
79486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79487       };
79488     }
79489   }
79490   jresult = (void *)result;
79491   return jresult;
79492 }
79493
79494
79495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79496   void * jresult ;
79497   Dali::Toolkit::AsyncImageLoader result;
79498
79499   {
79500     try {
79501       result = Dali::Toolkit::AsyncImageLoader::New();
79502     } catch (std::out_of_range& e) {
79503       {
79504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (std::exception& e) {
79507       {
79508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (...) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79513       };
79514     }
79515   }
79516   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79522   void * jresult ;
79523   Dali::BaseHandle arg1 ;
79524   Dali::BaseHandle *argp1 ;
79525   Dali::Toolkit::AsyncImageLoader result;
79526
79527   argp1 = (Dali::BaseHandle *)jarg1;
79528   if (!argp1) {
79529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79530     return 0;
79531   }
79532   arg1 = *argp1;
79533   {
79534     try {
79535       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79536     } catch (std::out_of_range& e) {
79537       {
79538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79539       };
79540     } catch (std::exception& e) {
79541       {
79542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79543       };
79544     } catch (...) {
79545       {
79546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79547       };
79548     }
79549   }
79550   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79551   return jresult;
79552 }
79553
79554
79555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79556   unsigned int jresult ;
79557   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79558   std::string *arg2 = 0 ;
79559   uint32_t result;
79560
79561   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79562   if (!jarg2) {
79563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79564     return 0;
79565   }
79566   std::string arg2_str(jarg2);
79567   arg2 = &arg2_str;
79568   {
79569     try {
79570       result = (arg1)->Load((std::string const &)*arg2);
79571     } catch (std::out_of_range& e) {
79572       {
79573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (std::exception& e) {
79576       {
79577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79578       };
79579     } catch (...) {
79580       {
79581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79582       };
79583     }
79584   }
79585   jresult = result;
79586
79587   //argout typemap for const std::string&
79588
79589   return jresult;
79590 }
79591
79592
79593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79594   unsigned int jresult ;
79595   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79596   std::string *arg2 = 0 ;
79597   Dali::ImageDimensions arg3 ;
79598   Dali::ImageDimensions *argp3 ;
79599   uint32_t result;
79600
79601   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79602   if (!jarg2) {
79603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79604     return 0;
79605   }
79606   std::string arg2_str(jarg2);
79607   arg2 = &arg2_str;
79608   argp3 = (Dali::ImageDimensions *)jarg3;
79609   if (!argp3) {
79610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79611     return 0;
79612   }
79613   arg3 = *argp3;
79614   {
79615     try {
79616       result = (arg1)->Load((std::string const &)*arg2,arg3);
79617     } catch (std::out_of_range& e) {
79618       {
79619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (std::exception& e) {
79622       {
79623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79624       };
79625     } catch (...) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79628       };
79629     }
79630   }
79631   jresult = result;
79632
79633   //argout typemap for const std::string&
79634
79635   return jresult;
79636 }
79637
79638
79639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79640   unsigned int jresult ;
79641   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79642   std::string *arg2 = 0 ;
79643   Dali::ImageDimensions arg3 ;
79644   Dali::FittingMode::Type arg4 ;
79645   Dali::SamplingMode::Type arg5 ;
79646   bool arg6 ;
79647   Dali::ImageDimensions *argp3 ;
79648   uint32_t result;
79649
79650   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79651   if (!jarg2) {
79652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79653     return 0;
79654   }
79655   std::string arg2_str(jarg2);
79656   arg2 = &arg2_str;
79657   argp3 = (Dali::ImageDimensions *)jarg3;
79658   if (!argp3) {
79659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79660     return 0;
79661   }
79662   arg3 = *argp3;
79663   arg4 = (Dali::FittingMode::Type)jarg4;
79664   arg5 = (Dali::SamplingMode::Type)jarg5;
79665   arg6 = jarg6 ? true : false;
79666   {
79667     try {
79668       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (...) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79680       };
79681     }
79682   }
79683   jresult = result;
79684
79685   //argout typemap for const std::string&
79686
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79692   unsigned int jresult ;
79693   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79694   uint32_t arg2 ;
79695   bool result;
79696
79697   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79698   arg2 = (uint32_t)jarg2;
79699   {
79700     try {
79701       result = (bool)(arg1)->Cancel(arg2);
79702     } catch (std::out_of_range& e) {
79703       {
79704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79705       };
79706     } catch (std::exception& e) {
79707       {
79708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79709       };
79710     } catch (...) {
79711       {
79712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79713       };
79714     }
79715   }
79716   jresult = result;
79717   return jresult;
79718 }
79719
79720
79721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79722   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79723
79724   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79725   {
79726     try {
79727       (arg1)->CancelAll();
79728     } catch (std::out_of_range& e) {
79729       {
79730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79731       };
79732     } catch (std::exception& e) {
79733       {
79734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79735       };
79736     } catch (...) {
79737       {
79738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79739       };
79740     }
79741   }
79742 }
79743
79744
79745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79746   void * jresult ;
79747   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79748   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79749
79750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79751   {
79752     try {
79753       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79754     } catch (std::out_of_range& e) {
79755       {
79756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79757       };
79758     } catch (std::exception& e) {
79759       {
79760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79761       };
79762     } catch (...) {
79763       {
79764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79765       };
79766     }
79767   }
79768   jresult = (void *)result;
79769   return jresult;
79770 }
79771
79772
79773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79774   void * jresult ;
79775   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79776   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79777
79778   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79779   {
79780     try {
79781       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79782     } catch (std::out_of_range& e) {
79783       {
79784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79785       };
79786     } catch (std::exception& e) {
79787       {
79788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79789       };
79790     } catch (...) {
79791       {
79792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79793       };
79794     }
79795   }
79796   jresult = (void *)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79802   void * jresult ;
79803   std::string *arg1 = 0 ;
79804   Dali::PixelData result;
79805
79806   if (!jarg1) {
79807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79808     return 0;
79809   }
79810   std::string arg1_str(jarg1);
79811   arg1 = &arg1_str;
79812   {
79813     try {
79814       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79815     } catch (std::out_of_range& e) {
79816       {
79817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79818       };
79819     } catch (std::exception& e) {
79820       {
79821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79822       };
79823     } catch (...) {
79824       {
79825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79826       };
79827     }
79828   }
79829   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79830
79831   //argout typemap for const std::string&
79832
79833   return jresult;
79834 }
79835
79836
79837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79838   void * jresult ;
79839   std::string *arg1 = 0 ;
79840   Dali::ImageDimensions arg2 ;
79841   Dali::ImageDimensions *argp2 ;
79842   Dali::PixelData result;
79843
79844   if (!jarg1) {
79845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79846     return 0;
79847   }
79848   std::string arg1_str(jarg1);
79849   arg1 = &arg1_str;
79850   argp2 = (Dali::ImageDimensions *)jarg2;
79851   if (!argp2) {
79852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79853     return 0;
79854   }
79855   arg2 = *argp2;
79856   {
79857     try {
79858       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79859     } catch (std::out_of_range& e) {
79860       {
79861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79862       };
79863     } catch (std::exception& e) {
79864       {
79865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79866       };
79867     } catch (...) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79870       };
79871     }
79872   }
79873   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79874
79875   //argout typemap for const std::string&
79876
79877   return jresult;
79878 }
79879
79880
79881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79882   void * jresult ;
79883   std::string *arg1 = 0 ;
79884   Dali::ImageDimensions arg2 ;
79885   Dali::FittingMode::Type arg3 ;
79886   Dali::SamplingMode::Type arg4 ;
79887   bool arg5 ;
79888   Dali::ImageDimensions *argp2 ;
79889   Dali::PixelData result;
79890
79891   if (!jarg1) {
79892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79893     return 0;
79894   }
79895   std::string arg1_str(jarg1);
79896   arg1 = &arg1_str;
79897   argp2 = (Dali::ImageDimensions *)jarg2;
79898   if (!argp2) {
79899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79900     return 0;
79901   }
79902   arg2 = *argp2;
79903   arg3 = (Dali::FittingMode::Type)jarg3;
79904   arg4 = (Dali::SamplingMode::Type)jarg4;
79905   arg5 = jarg5 ? true : false;
79906   {
79907     try {
79908       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79909     } catch (std::out_of_range& e) {
79910       {
79911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79912       };
79913     } catch (std::exception& e) {
79914       {
79915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (...) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79920       };
79921     }
79922   }
79923   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79924
79925   //argout typemap for const std::string&
79926
79927   return jresult;
79928 }
79929
79930
79931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79932   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79933
79934   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79935   {
79936     try {
79937       delete arg1;
79938     } catch (std::out_of_range& e) {
79939       {
79940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79941       };
79942     } catch (std::exception& e) {
79943       {
79944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79945       };
79946     } catch (...) {
79947       {
79948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79949       };
79950     }
79951   }
79952 }
79953
79954
79955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79956   void * jresult ;
79957   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79958   Dali::Actor arg2 ;
79959   Dali::Actor arg3 ;
79960   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79961   Dali::Actor *argp2 ;
79962   Dali::Actor *argp3 ;
79963   Dali::Actor result;
79964
79965   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79966   argp2 = (Dali::Actor *)jarg2;
79967   if (!argp2) {
79968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79969     return 0;
79970   }
79971   arg2 = *argp2;
79972   argp3 = (Dali::Actor *)jarg3;
79973   if (!argp3) {
79974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79975     return 0;
79976   }
79977   arg3 = *argp3;
79978   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79979   {
79980     try {
79981       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
79982     } catch (std::out_of_range& e) {
79983       {
79984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79985       };
79986     } catch (std::exception& e) {
79987       {
79988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79989       };
79990     } catch (...) {
79991       {
79992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79993       };
79994     }
79995   }
79996   jresult = new Dali::Actor((const Dali::Actor &)result);
79997   return jresult;
79998 }
79999
80000
80001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
80002   void * jresult ;
80003   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
80004
80005   {
80006     try {
80007       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
80008     } catch (std::out_of_range& e) {
80009       {
80010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80011       };
80012     } catch (std::exception& e) {
80013       {
80014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80015       };
80016     } catch (...) {
80017       {
80018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80019       };
80020     }
80021   }
80022   jresult = (void *)result;
80023   return jresult;
80024 }
80025
80026
80027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80028   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80029   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80030   if (director) {
80031     director->swig_connect_director(callback0);
80032   }
80033 }
80034
80035
80036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80037   KeyboardFocusManager arg1 ;
80038   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80039   KeyboardFocusManager *argp1 ;
80040
80041   argp1 = (KeyboardFocusManager *)jarg1;
80042   if (!argp1) {
80043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80044     return ;
80045   }
80046   arg1 = *argp1;
80047   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80048   if (!arg2) {
80049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80050     return ;
80051   }
80052   {
80053     try {
80054       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
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_Clear(void * jarg1) {
80073   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80074
80075   arg1 = (std::vector< unsigned int > *)jarg1;
80076   {
80077     try {
80078       (arg1)->clear();
80079     } catch (std::out_of_range& e) {
80080       {
80081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80082       };
80083     } catch (std::exception& e) {
80084       {
80085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80090       };
80091     }
80092   }
80093 }
80094
80095
80096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80097   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80098   unsigned int *arg2 = 0 ;
80099   unsigned int temp2 ;
80100
80101   arg1 = (std::vector< unsigned int > *)jarg1;
80102   temp2 = (unsigned int)jarg2;
80103   arg2 = &temp2;
80104   {
80105     try {
80106       (arg1)->push_back((unsigned int const &)*arg2);
80107     } catch (std::out_of_range& e) {
80108       {
80109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80110       };
80111     } catch (std::exception& e) {
80112       {
80113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80114       };
80115     } catch (...) {
80116       {
80117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80118       };
80119     }
80120   }
80121 }
80122
80123
80124 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80125   unsigned long jresult ;
80126   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80127   std::vector< unsigned int >::size_type result;
80128
80129   arg1 = (std::vector< unsigned int > *)jarg1;
80130   {
80131     try {
80132       result = ((std::vector< unsigned int > const *)arg1)->size();
80133     } catch (std::out_of_range& e) {
80134       {
80135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80136       };
80137     } catch (std::exception& e) {
80138       {
80139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (...) {
80142       {
80143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80144       };
80145     }
80146   }
80147   jresult = (unsigned long)result;
80148   return jresult;
80149 }
80150
80151
80152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80153   unsigned long jresult ;
80154   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80155   std::vector< unsigned int >::size_type result;
80156
80157   arg1 = (std::vector< unsigned int > *)jarg1;
80158   {
80159     try {
80160       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80161     } catch (std::out_of_range& e) {
80162       {
80163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80164       };
80165     } catch (std::exception& e) {
80166       {
80167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80168       };
80169     } catch (...) {
80170       {
80171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80172       };
80173     }
80174   }
80175   jresult = (unsigned long)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80181   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80182   std::vector< unsigned int >::size_type arg2 ;
80183
80184   arg1 = (std::vector< unsigned int > *)jarg1;
80185   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80186   {
80187     try {
80188       (arg1)->reserve(arg2);
80189     } catch (std::out_of_range& e) {
80190       {
80191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80192       };
80193     } catch (std::exception& e) {
80194       {
80195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80196       };
80197     } catch (...) {
80198       {
80199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80200       };
80201     }
80202   }
80203 }
80204
80205
80206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80207   void * jresult ;
80208   std::vector< unsigned int > *result = 0 ;
80209
80210   {
80211     try {
80212       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80213     } catch (std::out_of_range& e) {
80214       {
80215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80216       };
80217     } catch (std::exception& e) {
80218       {
80219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80220       };
80221     } catch (...) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80224       };
80225     }
80226   }
80227   jresult = (void *)result;
80228   return jresult;
80229 }
80230
80231
80232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80233   void * jresult ;
80234   std::vector< unsigned int > *arg1 = 0 ;
80235   std::vector< unsigned int > *result = 0 ;
80236
80237   arg1 = (std::vector< unsigned int > *)jarg1;
80238   if (!arg1) {
80239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80240     return 0;
80241   }
80242   {
80243     try {
80244       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80245     } catch (std::out_of_range& e) {
80246       {
80247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80248       };
80249     } catch (std::exception& e) {
80250       {
80251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80252       };
80253     } catch (...) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80256       };
80257     }
80258   }
80259   jresult = (void *)result;
80260   return jresult;
80261 }
80262
80263
80264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80265   void * jresult ;
80266   int arg1 ;
80267   std::vector< unsigned int > *result = 0 ;
80268
80269   arg1 = (int)jarg1;
80270   {
80271     try {
80272       try {
80273         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80274       }
80275       catch(std::out_of_range &_e) {
80276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80277         return 0;
80278       }
80279
80280     } catch (std::out_of_range& e) {
80281       {
80282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80283       };
80284     } catch (std::exception& e) {
80285       {
80286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80287       };
80288     } catch (...) {
80289       {
80290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80291       };
80292     }
80293   }
80294   jresult = (void *)result;
80295   return jresult;
80296 }
80297
80298
80299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80300   unsigned int jresult ;
80301   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80302   int arg2 ;
80303   unsigned int result;
80304
80305   arg1 = (std::vector< unsigned int > *)jarg1;
80306   arg2 = (int)jarg2;
80307   {
80308     try {
80309       try {
80310         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80311       }
80312       catch(std::out_of_range &_e) {
80313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80314         return 0;
80315       }
80316
80317     } catch (std::out_of_range& e) {
80318       {
80319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (std::exception& e) {
80322       {
80323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80324       };
80325     } catch (...) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80328       };
80329     }
80330   }
80331   jresult = result;
80332   return jresult;
80333 }
80334
80335
80336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80337   unsigned int jresult ;
80338   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80339   int arg2 ;
80340   unsigned int *result = 0 ;
80341
80342   arg1 = (std::vector< unsigned int > *)jarg1;
80343   arg2 = (int)jarg2;
80344   {
80345     try {
80346       try {
80347         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80348       }
80349       catch(std::out_of_range &_e) {
80350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80351         return 0;
80352       }
80353
80354     } catch (std::out_of_range& e) {
80355       {
80356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80357       };
80358     } catch (std::exception& e) {
80359       {
80360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80361       };
80362     } catch (...) {
80363       {
80364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80365       };
80366     }
80367   }
80368   jresult = *result;
80369   return jresult;
80370 }
80371
80372
80373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80374   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80375   int arg2 ;
80376   unsigned int *arg3 = 0 ;
80377   unsigned int temp3 ;
80378
80379   arg1 = (std::vector< unsigned int > *)jarg1;
80380   arg2 = (int)jarg2;
80381   temp3 = (unsigned int)jarg3;
80382   arg3 = &temp3;
80383   {
80384     try {
80385       try {
80386         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80387       }
80388       catch(std::out_of_range &_e) {
80389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80390         return ;
80391       }
80392
80393     } catch (std::out_of_range& e) {
80394       {
80395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80396       };
80397     } catch (std::exception& e) {
80398       {
80399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80400       };
80401     } catch (...) {
80402       {
80403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80404       };
80405     }
80406   }
80407 }
80408
80409
80410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80412   std::vector< unsigned int > *arg2 = 0 ;
80413
80414   arg1 = (std::vector< unsigned int > *)jarg1;
80415   arg2 = (std::vector< unsigned int > *)jarg2;
80416   if (!arg2) {
80417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80418     return ;
80419   }
80420   {
80421     try {
80422       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80423     } catch (std::out_of_range& e) {
80424       {
80425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (std::exception& e) {
80428       {
80429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80430       };
80431     } catch (...) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80434       };
80435     }
80436   }
80437 }
80438
80439
80440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80441   void * jresult ;
80442   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80443   int arg2 ;
80444   int arg3 ;
80445   std::vector< unsigned int > *result = 0 ;
80446
80447   arg1 = (std::vector< unsigned int > *)jarg1;
80448   arg2 = (int)jarg2;
80449   arg3 = (int)jarg3;
80450   {
80451     try {
80452       try {
80453         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80454       }
80455       catch(std::out_of_range &_e) {
80456         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80457         return 0;
80458       }
80459       catch(std::invalid_argument &_e) {
80460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80461         return 0;
80462       }
80463
80464     } catch (std::out_of_range& e) {
80465       {
80466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80467       };
80468     } catch (std::exception& e) {
80469       {
80470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80471       };
80472     } catch (...) {
80473       {
80474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80475       };
80476     }
80477   }
80478   jresult = (void *)result;
80479   return jresult;
80480 }
80481
80482
80483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80484   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80485   int arg2 ;
80486   unsigned int *arg3 = 0 ;
80487   unsigned int temp3 ;
80488
80489   arg1 = (std::vector< unsigned int > *)jarg1;
80490   arg2 = (int)jarg2;
80491   temp3 = (unsigned int)jarg3;
80492   arg3 = &temp3;
80493   {
80494     try {
80495       try {
80496         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80497       }
80498       catch(std::out_of_range &_e) {
80499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80500         return ;
80501       }
80502
80503     } catch (std::out_of_range& e) {
80504       {
80505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80506       };
80507     } catch (std::exception& e) {
80508       {
80509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80510       };
80511     } catch (...) {
80512       {
80513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80514       };
80515     }
80516   }
80517 }
80518
80519
80520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80521   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80522   int arg2 ;
80523   std::vector< unsigned int > *arg3 = 0 ;
80524
80525   arg1 = (std::vector< unsigned int > *)jarg1;
80526   arg2 = (int)jarg2;
80527   arg3 = (std::vector< unsigned int > *)jarg3;
80528   if (!arg3) {
80529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80530     return ;
80531   }
80532   {
80533     try {
80534       try {
80535         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80536       }
80537       catch(std::out_of_range &_e) {
80538         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80539         return ;
80540       }
80541
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80549       };
80550     } catch (...) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80553       };
80554     }
80555   }
80556 }
80557
80558
80559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80560   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80561   int arg2 ;
80562
80563   arg1 = (std::vector< unsigned int > *)jarg1;
80564   arg2 = (int)jarg2;
80565   {
80566     try {
80567       try {
80568         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80569       }
80570       catch(std::out_of_range &_e) {
80571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80572         return ;
80573       }
80574
80575     } catch (std::out_of_range& e) {
80576       {
80577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80578       };
80579     } catch (std::exception& e) {
80580       {
80581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80582       };
80583     } catch (...) {
80584       {
80585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80586       };
80587     }
80588   }
80589 }
80590
80591
80592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80593   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80594   int arg2 ;
80595   int arg3 ;
80596
80597   arg1 = (std::vector< unsigned int > *)jarg1;
80598   arg2 = (int)jarg2;
80599   arg3 = (int)jarg3;
80600   {
80601     try {
80602       try {
80603         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80604       }
80605       catch(std::out_of_range &_e) {
80606         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80607         return ;
80608       }
80609       catch(std::invalid_argument &_e) {
80610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80611         return ;
80612       }
80613
80614     } catch (std::out_of_range& e) {
80615       {
80616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80617       };
80618     } catch (std::exception& e) {
80619       {
80620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80621       };
80622     } catch (...) {
80623       {
80624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80625       };
80626     }
80627   }
80628 }
80629
80630
80631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80632   void * jresult ;
80633   unsigned int *arg1 = 0 ;
80634   int arg2 ;
80635   unsigned int temp1 ;
80636   std::vector< unsigned int > *result = 0 ;
80637
80638   temp1 = (unsigned int)jarg1;
80639   arg1 = &temp1;
80640   arg2 = (int)jarg2;
80641   {
80642     try {
80643       try {
80644         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80645       }
80646       catch(std::out_of_range &_e) {
80647         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80648         return 0;
80649       }
80650
80651     } catch (std::out_of_range& e) {
80652       {
80653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80654       };
80655     } catch (std::exception& e) {
80656       {
80657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80658       };
80659     } catch (...) {
80660       {
80661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80662       };
80663     }
80664   }
80665   jresult = (void *)result;
80666   return jresult;
80667 }
80668
80669
80670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80671   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80672
80673   arg1 = (std::vector< unsigned int > *)jarg1;
80674   {
80675     try {
80676       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80677     } catch (std::out_of_range& e) {
80678       {
80679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80680       };
80681     } catch (std::exception& e) {
80682       {
80683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80684       };
80685     } catch (...) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80688       };
80689     }
80690   }
80691 }
80692
80693
80694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80695   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80696   int arg2 ;
80697   int arg3 ;
80698
80699   arg1 = (std::vector< unsigned int > *)jarg1;
80700   arg2 = (int)jarg2;
80701   arg3 = (int)jarg3;
80702   {
80703     try {
80704       try {
80705         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80706       }
80707       catch(std::out_of_range &_e) {
80708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80709         return ;
80710       }
80711       catch(std::invalid_argument &_e) {
80712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80713         return ;
80714       }
80715
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80727       };
80728     }
80729   }
80730 }
80731
80732
80733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80734   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80735   int arg2 ;
80736   std::vector< unsigned int > *arg3 = 0 ;
80737
80738   arg1 = (std::vector< unsigned int > *)jarg1;
80739   arg2 = (int)jarg2;
80740   arg3 = (std::vector< unsigned int > *)jarg3;
80741   if (!arg3) {
80742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80743     return ;
80744   }
80745   {
80746     try {
80747       try {
80748         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80749       }
80750       catch(std::out_of_range &_e) {
80751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80752         return ;
80753       }
80754
80755     } catch (std::out_of_range& e) {
80756       {
80757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80758       };
80759     } catch (std::exception& e) {
80760       {
80761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80762       };
80763     } catch (...) {
80764       {
80765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80766       };
80767     }
80768   }
80769 }
80770
80771
80772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80773   unsigned int jresult ;
80774   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80775   unsigned int *arg2 = 0 ;
80776   unsigned int temp2 ;
80777   bool result;
80778
80779   arg1 = (std::vector< unsigned int > *)jarg1;
80780   temp2 = (unsigned int)jarg2;
80781   arg2 = &temp2;
80782   {
80783     try {
80784       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80785     } catch (std::out_of_range& e) {
80786       {
80787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80788       };
80789     } catch (std::exception& e) {
80790       {
80791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80792       };
80793     } catch (...) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80796       };
80797     }
80798   }
80799   jresult = result;
80800   return jresult;
80801 }
80802
80803
80804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80805   int jresult ;
80806   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80807   unsigned int *arg2 = 0 ;
80808   unsigned int temp2 ;
80809   int result;
80810
80811   arg1 = (std::vector< unsigned int > *)jarg1;
80812   temp2 = (unsigned int)jarg2;
80813   arg2 = &temp2;
80814   {
80815     try {
80816       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80817     } catch (std::out_of_range& e) {
80818       {
80819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80820       };
80821     } catch (std::exception& e) {
80822       {
80823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80824       };
80825     } catch (...) {
80826       {
80827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80828       };
80829     }
80830   }
80831   jresult = result;
80832   return jresult;
80833 }
80834
80835
80836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80837   int jresult ;
80838   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80839   unsigned int *arg2 = 0 ;
80840   unsigned int temp2 ;
80841   int result;
80842
80843   arg1 = (std::vector< unsigned int > *)jarg1;
80844   temp2 = (unsigned int)jarg2;
80845   arg2 = &temp2;
80846   {
80847     try {
80848       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80849     } catch (std::out_of_range& e) {
80850       {
80851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80852       };
80853     } catch (std::exception& e) {
80854       {
80855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (...) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80860       };
80861     }
80862   }
80863   jresult = result;
80864   return jresult;
80865 }
80866
80867
80868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80869   unsigned int jresult ;
80870   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80871   unsigned int *arg2 = 0 ;
80872   unsigned int temp2 ;
80873   bool result;
80874
80875   arg1 = (std::vector< unsigned int > *)jarg1;
80876   temp2 = (unsigned int)jarg2;
80877   arg2 = &temp2;
80878   {
80879     try {
80880       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80888       };
80889     } catch (...) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80892       };
80893     }
80894   }
80895   jresult = result;
80896   return jresult;
80897 }
80898
80899
80900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80902
80903   arg1 = (std::vector< unsigned int > *)jarg1;
80904   {
80905     try {
80906       delete arg1;
80907     } catch (std::out_of_range& e) {
80908       {
80909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80910       };
80911     } catch (std::exception& e) {
80912       {
80913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (...) {
80916       {
80917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80918       };
80919     }
80920   }
80921 }
80922
80923
80924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80925   void * jresult ;
80926   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80927
80928   {
80929     try {
80930       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80931     } catch (std::out_of_range& e) {
80932       {
80933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80934       };
80935     } catch (std::exception& e) {
80936       {
80937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80938       };
80939     } catch (...) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80942       };
80943     }
80944   }
80945   jresult = (void *)result;
80946   return jresult;
80947 }
80948
80949
80950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80951   void * jresult ;
80952   unsigned int arg1 ;
80953   Dali::Actor arg2 ;
80954   Dali::Actor *argp2 ;
80955   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80956
80957   arg1 = (unsigned int)jarg1;
80958   argp2 = (Dali::Actor *)jarg2;
80959   if (!argp2) {
80960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80961     return 0;
80962   }
80963   arg2 = *argp2;
80964   {
80965     try {
80966       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80978       };
80979     }
80980   }
80981   jresult = (void *)result;
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
80987   void * jresult ;
80988   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
80989   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80990
80991   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80992   if (!arg1) {
80993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
80994     return 0;
80995   }
80996   {
80997     try {
80998       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
80999     } catch (std::out_of_range& e) {
81000       {
81001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81002       };
81003     } catch (std::exception& e) {
81004       {
81005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (...) {
81008       {
81009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81010       };
81011     }
81012   }
81013   jresult = (void *)result;
81014   return jresult;
81015 }
81016
81017
81018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81019   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81020   unsigned int arg2 ;
81021
81022   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81023   arg2 = (unsigned int)jarg2;
81024   if (arg1) (arg1)->first = arg2;
81025 }
81026
81027
81028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81029   unsigned int jresult ;
81030   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81031   unsigned int result;
81032
81033   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81034   result = (unsigned int) ((arg1)->first);
81035   jresult = result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81041   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81042   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81043
81044   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81045   arg2 = (Dali::Actor *)jarg2;
81046   if (arg1) (arg1)->second = *arg2;
81047 }
81048
81049
81050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81051   void * jresult ;
81052   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81053   Dali::Actor *result = 0 ;
81054
81055   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81056   result = (Dali::Actor *)& ((arg1)->second);
81057   jresult = (void *)result;
81058   return jresult;
81059 }
81060
81061
81062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81063   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81064
81065   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81066   {
81067     try {
81068       delete arg1;
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_Clear(void * jarg1) {
81087   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81088
81089   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81090   {
81091     try {
81092       (arg1)->clear();
81093     } catch (std::out_of_range& e) {
81094       {
81095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81096       };
81097     } catch (std::exception& e) {
81098       {
81099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81100       };
81101     } catch (...) {
81102       {
81103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81104       };
81105     }
81106   }
81107 }
81108
81109
81110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81111   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81112   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81113
81114   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81115   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81116   if (!arg2) {
81117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81118     return ;
81119   }
81120   {
81121     try {
81122       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81123     } catch (std::out_of_range& e) {
81124       {
81125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81126       };
81127     } catch (std::exception& e) {
81128       {
81129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81130       };
81131     } catch (...) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81134       };
81135     }
81136   }
81137 }
81138
81139
81140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81141   unsigned long jresult ;
81142   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81143   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81144
81145   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81146   {
81147     try {
81148       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81149     } catch (std::out_of_range& e) {
81150       {
81151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (std::exception& e) {
81154       {
81155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81160       };
81161     }
81162   }
81163   jresult = (unsigned long)result;
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81169   unsigned long jresult ;
81170   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81171   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81172
81173   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81174   {
81175     try {
81176       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81177     } catch (std::out_of_range& e) {
81178       {
81179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81180       };
81181     } catch (std::exception& e) {
81182       {
81183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81184       };
81185     } catch (...) {
81186       {
81187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81188       };
81189     }
81190   }
81191   jresult = (unsigned long)result;
81192   return jresult;
81193 }
81194
81195
81196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81197   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81198   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81199
81200   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81201   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81202   {
81203     try {
81204       (arg1)->reserve(arg2);
81205     } catch (std::out_of_range& e) {
81206       {
81207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81208       };
81209     } catch (std::exception& e) {
81210       {
81211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81212       };
81213     } catch (...) {
81214       {
81215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81216       };
81217     }
81218   }
81219 }
81220
81221
81222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81223   void * jresult ;
81224   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81225
81226   {
81227     try {
81228       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81229     } catch (std::out_of_range& e) {
81230       {
81231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81232       };
81233     } catch (std::exception& e) {
81234       {
81235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81236       };
81237     } catch (...) {
81238       {
81239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81240       };
81241     }
81242   }
81243   jresult = (void *)result;
81244   return jresult;
81245 }
81246
81247
81248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81249   void * jresult ;
81250   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81251   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81252
81253   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81254   if (!arg1) {
81255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81256     return 0;
81257   }
81258   {
81259     try {
81260       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);
81261     } catch (std::out_of_range& e) {
81262       {
81263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81264       };
81265     } catch (std::exception& e) {
81266       {
81267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81268       };
81269     } catch (...) {
81270       {
81271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81272       };
81273     }
81274   }
81275   jresult = (void *)result;
81276   return jresult;
81277 }
81278
81279
81280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81281   void * jresult ;
81282   int arg1 ;
81283   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81284
81285   arg1 = (int)jarg1;
81286   {
81287     try {
81288       try {
81289         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);
81290       }
81291       catch(std::out_of_range &_e) {
81292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81293         return 0;
81294       }
81295
81296     } catch (std::out_of_range& e) {
81297       {
81298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81299       };
81300     } catch (std::exception& e) {
81301       {
81302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81303       };
81304     } catch (...) {
81305       {
81306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81307       };
81308     }
81309   }
81310   jresult = (void *)result;
81311   return jresult;
81312 }
81313
81314
81315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81316   void * jresult ;
81317   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81318   int arg2 ;
81319   std::pair< unsigned int,Dali::Actor > result;
81320
81321   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81322   arg2 = (int)jarg2;
81323   {
81324     try {
81325       try {
81326         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81327       }
81328       catch(std::out_of_range &_e) {
81329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81330         return 0;
81331       }
81332
81333     } catch (std::out_of_range& e) {
81334       {
81335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81336       };
81337     } catch (std::exception& e) {
81338       {
81339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (...) {
81342       {
81343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81344       };
81345     }
81346   }
81347   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81348   return jresult;
81349 }
81350
81351
81352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81353   void * jresult ;
81354   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81355   int arg2 ;
81356   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81357
81358   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81359   arg2 = (int)jarg2;
81360   {
81361     try {
81362       try {
81363         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81364       }
81365       catch(std::out_of_range &_e) {
81366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81367         return 0;
81368       }
81369
81370     } catch (std::out_of_range& e) {
81371       {
81372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81373       };
81374     } catch (std::exception& e) {
81375       {
81376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81377       };
81378     } catch (...) {
81379       {
81380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81381       };
81382     }
81383   }
81384   jresult = (void *)result;
81385   return jresult;
81386 }
81387
81388
81389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81390   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81391   int arg2 ;
81392   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81393
81394   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81395   arg2 = (int)jarg2;
81396   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81397   if (!arg3) {
81398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81399     return ;
81400   }
81401   {
81402     try {
81403       try {
81404         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);
81405       }
81406       catch(std::out_of_range &_e) {
81407         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81408         return ;
81409       }
81410
81411     } catch (std::out_of_range& e) {
81412       {
81413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81414       };
81415     } catch (std::exception& e) {
81416       {
81417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81418       };
81419     } catch (...) {
81420       {
81421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81422       };
81423     }
81424   }
81425 }
81426
81427
81428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81429   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81430   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81431
81432   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81433   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81434   if (!arg2) {
81435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81436     return ;
81437   }
81438   {
81439     try {
81440       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);
81441     } catch (std::out_of_range& e) {
81442       {
81443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81444       };
81445     } catch (std::exception& e) {
81446       {
81447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81448       };
81449     } catch (...) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81452       };
81453     }
81454   }
81455 }
81456
81457
81458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81459   void * jresult ;
81460   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81461   int arg2 ;
81462   int arg3 ;
81463   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81464
81465   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81466   arg2 = (int)jarg2;
81467   arg3 = (int)jarg3;
81468   {
81469     try {
81470       try {
81471         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);
81472       }
81473       catch(std::out_of_range &_e) {
81474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81475         return 0;
81476       }
81477       catch(std::invalid_argument &_e) {
81478         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81479         return 0;
81480       }
81481
81482     } catch (std::out_of_range& e) {
81483       {
81484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81485       };
81486     } catch (std::exception& e) {
81487       {
81488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81489       };
81490     } catch (...) {
81491       {
81492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81493       };
81494     }
81495   }
81496   jresult = (void *)result;
81497   return jresult;
81498 }
81499
81500
81501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81502   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81503   int arg2 ;
81504   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81505
81506   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81507   arg2 = (int)jarg2;
81508   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81509   if (!arg3) {
81510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81511     return ;
81512   }
81513   {
81514     try {
81515       try {
81516         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);
81517       }
81518       catch(std::out_of_range &_e) {
81519         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81520         return ;
81521       }
81522
81523     } catch (std::out_of_range& e) {
81524       {
81525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81526       };
81527     } catch (std::exception& e) {
81528       {
81529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81530       };
81531     } catch (...) {
81532       {
81533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81534       };
81535     }
81536   }
81537 }
81538
81539
81540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81541   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81542   int arg2 ;
81543   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81544
81545   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81546   arg2 = (int)jarg2;
81547   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81548   if (!arg3) {
81549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81550     return ;
81551   }
81552   {
81553     try {
81554       try {
81555         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);
81556       }
81557       catch(std::out_of_range &_e) {
81558         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81559         return ;
81560       }
81561
81562     } catch (std::out_of_range& e) {
81563       {
81564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81565       };
81566     } catch (std::exception& e) {
81567       {
81568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81569       };
81570     } catch (...) {
81571       {
81572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81573       };
81574     }
81575   }
81576 }
81577
81578
81579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81580   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81581   int arg2 ;
81582
81583   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81584   arg2 = (int)jarg2;
81585   {
81586     try {
81587       try {
81588         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81589       }
81590       catch(std::out_of_range &_e) {
81591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81592         return ;
81593       }
81594
81595     } catch (std::out_of_range& e) {
81596       {
81597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81598       };
81599     } catch (std::exception& e) {
81600       {
81601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81602       };
81603     } catch (...) {
81604       {
81605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81606       };
81607     }
81608   }
81609 }
81610
81611
81612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81613   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81614   int arg2 ;
81615   int arg3 ;
81616
81617   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81618   arg2 = (int)jarg2;
81619   arg3 = (int)jarg3;
81620   {
81621     try {
81622       try {
81623         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81624       }
81625       catch(std::out_of_range &_e) {
81626         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81627         return ;
81628       }
81629       catch(std::invalid_argument &_e) {
81630         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81631         return ;
81632       }
81633
81634     } catch (std::out_of_range& e) {
81635       {
81636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81637       };
81638     } catch (std::exception& e) {
81639       {
81640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81641       };
81642     } catch (...) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81645       };
81646     }
81647   }
81648 }
81649
81650
81651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81652   void * jresult ;
81653   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81654   int arg2 ;
81655   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81656
81657   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81658   if (!arg1) {
81659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81660     return 0;
81661   }
81662   arg2 = (int)jarg2;
81663   {
81664     try {
81665       try {
81666         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);
81667       }
81668       catch(std::out_of_range &_e) {
81669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81670         return 0;
81671       }
81672
81673     } catch (std::out_of_range& e) {
81674       {
81675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81676       };
81677     } catch (std::exception& e) {
81678       {
81679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81680       };
81681     } catch (...) {
81682       {
81683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81684       };
81685     }
81686   }
81687   jresult = (void *)result;
81688   return jresult;
81689 }
81690
81691
81692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81693   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81694
81695   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81696   {
81697     try {
81698       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81699     } catch (std::out_of_range& e) {
81700       {
81701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81702       };
81703     } catch (std::exception& e) {
81704       {
81705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81706       };
81707     } catch (...) {
81708       {
81709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81710       };
81711     }
81712   }
81713 }
81714
81715
81716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81717   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81718   int arg2 ;
81719   int arg3 ;
81720
81721   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81722   arg2 = (int)jarg2;
81723   arg3 = (int)jarg3;
81724   {
81725     try {
81726       try {
81727         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81728       }
81729       catch(std::out_of_range &_e) {
81730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81731         return ;
81732       }
81733       catch(std::invalid_argument &_e) {
81734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81735         return ;
81736       }
81737
81738     } catch (std::out_of_range& e) {
81739       {
81740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81741       };
81742     } catch (std::exception& e) {
81743       {
81744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81745       };
81746     } catch (...) {
81747       {
81748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81749       };
81750     }
81751   }
81752 }
81753
81754
81755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81756   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81757   int arg2 ;
81758   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81759
81760   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81761   arg2 = (int)jarg2;
81762   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81763   if (!arg3) {
81764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81765     return ;
81766   }
81767   {
81768     try {
81769       try {
81770         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);
81771       }
81772       catch(std::out_of_range &_e) {
81773         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81774         return ;
81775       }
81776
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_delete_ItemContainer(void * jarg1) {
81795   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81796
81797   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81798   {
81799     try {
81800       delete arg1;
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81812       };
81813     }
81814   }
81815 }
81816
81817
81818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81820
81821   arg1 = (std::vector< Dali::Actor > *)jarg1;
81822   {
81823     try {
81824       (arg1)->clear();
81825     } catch (std::out_of_range& e) {
81826       {
81827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81828       };
81829     } catch (std::exception& e) {
81830       {
81831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81832       };
81833     } catch (...) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81836       };
81837     }
81838   }
81839 }
81840
81841
81842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81843   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81844   Dali::Actor *arg2 = 0 ;
81845
81846   arg1 = (std::vector< Dali::Actor > *)jarg1;
81847   arg2 = (Dali::Actor *)jarg2;
81848   if (!arg2) {
81849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81850     return ;
81851   }
81852   {
81853     try {
81854       (arg1)->push_back((Dali::Actor const &)*arg2);
81855     } catch (std::out_of_range& e) {
81856       {
81857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81858       };
81859     } catch (std::exception& e) {
81860       {
81861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81862       };
81863     } catch (...) {
81864       {
81865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81866       };
81867     }
81868   }
81869 }
81870
81871
81872 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81873   unsigned long jresult ;
81874   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81875   std::vector< Dali::Actor >::size_type result;
81876
81877   arg1 = (std::vector< Dali::Actor > *)jarg1;
81878   {
81879     try {
81880       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81881     } catch (std::out_of_range& e) {
81882       {
81883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81884       };
81885     } catch (std::exception& e) {
81886       {
81887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81888       };
81889     } catch (...) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81892       };
81893     }
81894   }
81895   jresult = (unsigned long)result;
81896   return jresult;
81897 }
81898
81899
81900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81901   unsigned long jresult ;
81902   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81903   std::vector< Dali::Actor >::size_type result;
81904
81905   arg1 = (std::vector< Dali::Actor > *)jarg1;
81906   {
81907     try {
81908       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81909     } catch (std::out_of_range& e) {
81910       {
81911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81912       };
81913     } catch (std::exception& e) {
81914       {
81915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81916       };
81917     } catch (...) {
81918       {
81919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81920       };
81921     }
81922   }
81923   jresult = (unsigned long)result;
81924   return jresult;
81925 }
81926
81927
81928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81929   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81930   std::vector< Dali::Actor >::size_type arg2 ;
81931
81932   arg1 = (std::vector< Dali::Actor > *)jarg1;
81933   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81934   {
81935     try {
81936       (arg1)->reserve(arg2);
81937     } catch (std::out_of_range& e) {
81938       {
81939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81940       };
81941     } catch (std::exception& e) {
81942       {
81943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81944       };
81945     } catch (...) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81948       };
81949     }
81950   }
81951 }
81952
81953
81954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81955   void * jresult ;
81956   std::vector< Dali::Actor > *result = 0 ;
81957
81958   {
81959     try {
81960       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81961     } catch (std::out_of_range& e) {
81962       {
81963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81964       };
81965     } catch (std::exception& e) {
81966       {
81967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81968       };
81969     } catch (...) {
81970       {
81971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81972       };
81973     }
81974   }
81975   jresult = (void *)result;
81976   return jresult;
81977 }
81978
81979
81980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
81981   void * jresult ;
81982   std::vector< Dali::Actor > *arg1 = 0 ;
81983   std::vector< Dali::Actor > *result = 0 ;
81984
81985   arg1 = (std::vector< Dali::Actor > *)jarg1;
81986   if (!arg1) {
81987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
81988     return 0;
81989   }
81990   {
81991     try {
81992       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
81993     } catch (std::out_of_range& e) {
81994       {
81995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81996       };
81997     } catch (std::exception& e) {
81998       {
81999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82000       };
82001     } catch (...) {
82002       {
82003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82004       };
82005     }
82006   }
82007   jresult = (void *)result;
82008   return jresult;
82009 }
82010
82011
82012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82013   void * jresult ;
82014   int arg1 ;
82015   std::vector< Dali::Actor > *result = 0 ;
82016
82017   arg1 = (int)jarg1;
82018   {
82019     try {
82020       try {
82021         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82022       }
82023       catch(std::out_of_range &_e) {
82024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82025         return 0;
82026       }
82027
82028     } catch (std::out_of_range& e) {
82029       {
82030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82031       };
82032     } catch (std::exception& e) {
82033       {
82034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82035       };
82036     } catch (...) {
82037       {
82038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82039       };
82040     }
82041   }
82042   jresult = (void *)result;
82043   return jresult;
82044 }
82045
82046
82047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82048   void * jresult ;
82049   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82050   int arg2 ;
82051   Dali::Actor result;
82052
82053   arg1 = (std::vector< Dali::Actor > *)jarg1;
82054   arg2 = (int)jarg2;
82055   {
82056     try {
82057       try {
82058         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82059       }
82060       catch(std::out_of_range &_e) {
82061         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82062         return 0;
82063       }
82064
82065     } catch (std::out_of_range& e) {
82066       {
82067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (std::exception& e) {
82070       {
82071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (...) {
82074       {
82075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82076       };
82077     }
82078   }
82079   jresult = new Dali::Actor((const Dali::Actor &)result);
82080   return jresult;
82081 }
82082
82083
82084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82085   void * jresult ;
82086   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82087   int arg2 ;
82088   Dali::Actor *result = 0 ;
82089
82090   arg1 = (std::vector< Dali::Actor > *)jarg1;
82091   arg2 = (int)jarg2;
82092   {
82093     try {
82094       try {
82095         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82096       }
82097       catch(std::out_of_range &_e) {
82098         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82099         return 0;
82100       }
82101
82102     } catch (std::out_of_range& e) {
82103       {
82104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82105       };
82106     } catch (std::exception& e) {
82107       {
82108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82109       };
82110     } catch (...) {
82111       {
82112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82113       };
82114     }
82115   }
82116   jresult = (void *)result;
82117   return jresult;
82118 }
82119
82120
82121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82122   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82123   int arg2 ;
82124   Dali::Actor *arg3 = 0 ;
82125
82126   arg1 = (std::vector< Dali::Actor > *)jarg1;
82127   arg2 = (int)jarg2;
82128   arg3 = (Dali::Actor *)jarg3;
82129   if (!arg3) {
82130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82131     return ;
82132   }
82133   {
82134     try {
82135       try {
82136         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82137       }
82138       catch(std::out_of_range &_e) {
82139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82140         return ;
82141       }
82142
82143     } catch (std::out_of_range& e) {
82144       {
82145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82146       };
82147     } catch (std::exception& e) {
82148       {
82149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82150       };
82151     } catch (...) {
82152       {
82153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82154       };
82155     }
82156   }
82157 }
82158
82159
82160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82161   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82162   std::vector< Dali::Actor > *arg2 = 0 ;
82163
82164   arg1 = (std::vector< Dali::Actor > *)jarg1;
82165   arg2 = (std::vector< Dali::Actor > *)jarg2;
82166   if (!arg2) {
82167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82168     return ;
82169   }
82170   {
82171     try {
82172       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82173     } catch (std::out_of_range& e) {
82174       {
82175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82176       };
82177     } catch (std::exception& e) {
82178       {
82179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82180       };
82181     } catch (...) {
82182       {
82183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82184       };
82185     }
82186   }
82187 }
82188
82189
82190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82191   void * jresult ;
82192   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82193   int arg2 ;
82194   int arg3 ;
82195   std::vector< Dali::Actor > *result = 0 ;
82196
82197   arg1 = (std::vector< Dali::Actor > *)jarg1;
82198   arg2 = (int)jarg2;
82199   arg3 = (int)jarg3;
82200   {
82201     try {
82202       try {
82203         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82204       }
82205       catch(std::out_of_range &_e) {
82206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82207         return 0;
82208       }
82209       catch(std::invalid_argument &_e) {
82210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82211         return 0;
82212       }
82213
82214     } catch (std::out_of_range& e) {
82215       {
82216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82217       };
82218     } catch (std::exception& e) {
82219       {
82220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82221       };
82222     } catch (...) {
82223       {
82224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82225       };
82226     }
82227   }
82228   jresult = (void *)result;
82229   return jresult;
82230 }
82231
82232
82233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82234   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82235   int arg2 ;
82236   Dali::Actor *arg3 = 0 ;
82237
82238   arg1 = (std::vector< Dali::Actor > *)jarg1;
82239   arg2 = (int)jarg2;
82240   arg3 = (Dali::Actor *)jarg3;
82241   if (!arg3) {
82242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82243     return ;
82244   }
82245   {
82246     try {
82247       try {
82248         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82249       }
82250       catch(std::out_of_range &_e) {
82251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82252         return ;
82253       }
82254
82255     } catch (std::out_of_range& e) {
82256       {
82257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82258       };
82259     } catch (std::exception& e) {
82260       {
82261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82262       };
82263     } catch (...) {
82264       {
82265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82266       };
82267     }
82268   }
82269 }
82270
82271
82272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82273   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82274   int arg2 ;
82275   std::vector< Dali::Actor > *arg3 = 0 ;
82276
82277   arg1 = (std::vector< Dali::Actor > *)jarg1;
82278   arg2 = (int)jarg2;
82279   arg3 = (std::vector< Dali::Actor > *)jarg3;
82280   if (!arg3) {
82281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82282     return ;
82283   }
82284   {
82285     try {
82286       try {
82287         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82288       }
82289       catch(std::out_of_range &_e) {
82290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82291         return ;
82292       }
82293
82294     } catch (std::out_of_range& e) {
82295       {
82296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82297       };
82298     } catch (std::exception& e) {
82299       {
82300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82301       };
82302     } catch (...) {
82303       {
82304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82305       };
82306     }
82307   }
82308 }
82309
82310
82311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82312   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82313   int arg2 ;
82314
82315   arg1 = (std::vector< Dali::Actor > *)jarg1;
82316   arg2 = (int)jarg2;
82317   {
82318     try {
82319       try {
82320         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82321       }
82322       catch(std::out_of_range &_e) {
82323         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82324         return ;
82325       }
82326
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82338       };
82339     }
82340   }
82341 }
82342
82343
82344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82345   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82346   int arg2 ;
82347   int arg3 ;
82348
82349   arg1 = (std::vector< Dali::Actor > *)jarg1;
82350   arg2 = (int)jarg2;
82351   arg3 = (int)jarg3;
82352   {
82353     try {
82354       try {
82355         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82356       }
82357       catch(std::out_of_range &_e) {
82358         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82359         return ;
82360       }
82361       catch(std::invalid_argument &_e) {
82362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82363         return ;
82364       }
82365
82366     } catch (std::out_of_range& e) {
82367       {
82368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82369       };
82370     } catch (std::exception& e) {
82371       {
82372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82373       };
82374     } catch (...) {
82375       {
82376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82377       };
82378     }
82379   }
82380 }
82381
82382
82383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82384   void * jresult ;
82385   Dali::Actor *arg1 = 0 ;
82386   int arg2 ;
82387   std::vector< Dali::Actor > *result = 0 ;
82388
82389   arg1 = (Dali::Actor *)jarg1;
82390   if (!arg1) {
82391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82392     return 0;
82393   }
82394   arg2 = (int)jarg2;
82395   {
82396     try {
82397       try {
82398         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82399       }
82400       catch(std::out_of_range &_e) {
82401         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82402         return 0;
82403       }
82404
82405     } catch (std::out_of_range& e) {
82406       {
82407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82408       };
82409     } catch (std::exception& e) {
82410       {
82411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82412       };
82413     } catch (...) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82416       };
82417     }
82418   }
82419   jresult = (void *)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82426
82427   arg1 = (std::vector< Dali::Actor > *)jarg1;
82428   {
82429     try {
82430       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82431     } catch (std::out_of_range& e) {
82432       {
82433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82434       };
82435     } catch (std::exception& e) {
82436       {
82437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82438       };
82439     } catch (...) {
82440       {
82441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82442       };
82443     }
82444   }
82445 }
82446
82447
82448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82449   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82450   int arg2 ;
82451   int arg3 ;
82452
82453   arg1 = (std::vector< Dali::Actor > *)jarg1;
82454   arg2 = (int)jarg2;
82455   arg3 = (int)jarg3;
82456   {
82457     try {
82458       try {
82459         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82460       }
82461       catch(std::out_of_range &_e) {
82462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82463         return ;
82464       }
82465       catch(std::invalid_argument &_e) {
82466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82467         return ;
82468       }
82469
82470     } catch (std::out_of_range& e) {
82471       {
82472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82473       };
82474     } catch (std::exception& e) {
82475       {
82476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82477       };
82478     } catch (...) {
82479       {
82480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82481       };
82482     }
82483   }
82484 }
82485
82486
82487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82488   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82489   int arg2 ;
82490   std::vector< Dali::Actor > *arg3 = 0 ;
82491
82492   arg1 = (std::vector< Dali::Actor > *)jarg1;
82493   arg2 = (int)jarg2;
82494   arg3 = (std::vector< Dali::Actor > *)jarg3;
82495   if (!arg3) {
82496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82497     return ;
82498   }
82499   {
82500     try {
82501       try {
82502         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82503       }
82504       catch(std::out_of_range &_e) {
82505         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82506         return ;
82507       }
82508
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 void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82527   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82528
82529   arg1 = (std::vector< Dali::Actor > *)jarg1;
82530   {
82531     try {
82532       delete arg1;
82533     } catch (std::out_of_range& e) {
82534       {
82535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82536       };
82537     } catch (std::exception& e) {
82538       {
82539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82540       };
82541     } catch (...) {
82542       {
82543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82544       };
82545     }
82546   }
82547 }
82548
82549
82550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82551   unsigned int jresult ;
82552   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82553   bool result;
82554
82555   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82556   {
82557     try {
82558       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82559     } catch (std::out_of_range& e) {
82560       {
82561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82562       };
82563     } catch (std::exception& e) {
82564       {
82565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82566       };
82567     } catch (...) {
82568       {
82569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82570       };
82571     }
82572   }
82573   jresult = result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82579   unsigned long jresult ;
82580   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82581   std::size_t result;
82582
82583   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82584   {
82585     try {
82586       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82587     } catch (std::out_of_range& e) {
82588       {
82589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82590       };
82591     } catch (std::exception& e) {
82592       {
82593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82594       };
82595     } catch (...) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82598       };
82599     }
82600   }
82601   jresult = (unsigned long)result;
82602   return jresult;
82603 }
82604
82605
82606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82607   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82608   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82609
82610   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82611   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82612   {
82613     try {
82614       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82615     } catch (std::out_of_range& e) {
82616       {
82617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82618       };
82619     } catch (std::exception& e) {
82620       {
82621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82626       };
82627     }
82628   }
82629 }
82630
82631
82632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82633   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82634   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82635
82636   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82637   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82638   {
82639     try {
82640       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82641     } catch (std::out_of_range& e) {
82642       {
82643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82644       };
82645     } catch (std::exception& e) {
82646       {
82647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82648       };
82649     } catch (...) {
82650       {
82651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82652       };
82653     }
82654   }
82655 }
82656
82657
82658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82659   unsigned int jresult ;
82660   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82661   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82662   bool result;
82663
82664   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82665   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82666   if (!arg2) {
82667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82668     return 0;
82669   }
82670   {
82671     try {
82672       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82673     } catch (std::out_of_range& e) {
82674       {
82675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82676       };
82677     } catch (std::exception& e) {
82678       {
82679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82680       };
82681     } catch (...) {
82682       {
82683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82684       };
82685     }
82686   }
82687   jresult = result;
82688   return jresult;
82689 }
82690
82691
82692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82693   void * jresult ;
82694   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82695
82696   {
82697     try {
82698       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82699     } catch (std::out_of_range& e) {
82700       {
82701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82702       };
82703     } catch (std::exception& e) {
82704       {
82705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82706       };
82707     } catch (...) {
82708       {
82709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82710       };
82711     }
82712   }
82713   jresult = (void *)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82719   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82720
82721   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82722   {
82723     try {
82724       delete arg1;
82725     } catch (std::out_of_range& e) {
82726       {
82727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82728       };
82729     } catch (std::exception& e) {
82730       {
82731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82732       };
82733     } catch (...) {
82734       {
82735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82736       };
82737     }
82738   }
82739 }
82740
82741
82742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82743   unsigned int jresult ;
82744   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82745   bool result;
82746
82747   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82748   {
82749     try {
82750       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);
82751     } catch (std::out_of_range& e) {
82752       {
82753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82754       };
82755     } catch (std::exception& e) {
82756       {
82757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82758       };
82759     } catch (...) {
82760       {
82761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82762       };
82763     }
82764   }
82765   jresult = result;
82766   return jresult;
82767 }
82768
82769
82770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82771   unsigned long jresult ;
82772   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82773   std::size_t result;
82774
82775   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82776   {
82777     try {
82778       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);
82779     } catch (std::out_of_range& e) {
82780       {
82781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82782       };
82783     } catch (std::exception& e) {
82784       {
82785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82786       };
82787     } catch (...) {
82788       {
82789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82790       };
82791     }
82792   }
82793   jresult = (unsigned long)result;
82794   return jresult;
82795 }
82796
82797
82798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82799   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82800   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82801
82802   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82803   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82804   {
82805     try {
82806       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82807     } catch (std::out_of_range& e) {
82808       {
82809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82810       };
82811     } catch (std::exception& e) {
82812       {
82813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82814       };
82815     } catch (...) {
82816       {
82817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82818       };
82819     }
82820   }
82821 }
82822
82823
82824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82825   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82826   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82827
82828   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82829   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82830   {
82831     try {
82832       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82833     } catch (std::out_of_range& e) {
82834       {
82835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82836       };
82837     } catch (std::exception& e) {
82838       {
82839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82840       };
82841     } catch (...) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82844       };
82845     }
82846   }
82847 }
82848
82849
82850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82851   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82852   Dali::Actor arg2 ;
82853   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82854   Dali::Actor *argp2 ;
82855
82856   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82857   argp2 = (Dali::Actor *)jarg2;
82858   if (!argp2) {
82859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82860     return ;
82861   }
82862   arg2 = *argp2;
82863   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82864   {
82865     try {
82866       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82867     } catch (std::out_of_range& e) {
82868       {
82869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82870       };
82871     } catch (std::exception& e) {
82872       {
82873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82874       };
82875     } catch (...) {
82876       {
82877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82878       };
82879     }
82880   }
82881 }
82882
82883
82884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82885   void * jresult ;
82886   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82887
82888   {
82889     try {
82890       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82891     } catch (std::out_of_range& e) {
82892       {
82893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82894       };
82895     } catch (std::exception& e) {
82896       {
82897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82898       };
82899     } catch (...) {
82900       {
82901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82902       };
82903     }
82904   }
82905   jresult = (void *)result;
82906   return jresult;
82907 }
82908
82909
82910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82911   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82912
82913   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82914   {
82915     try {
82916       delete arg1;
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82924       };
82925     } catch (...) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82928       };
82929     }
82930   }
82931 }
82932
82933
82934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82935   unsigned int jresult ;
82936   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82937   bool result;
82938
82939   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82940   {
82941     try {
82942       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82943     } catch (std::out_of_range& e) {
82944       {
82945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82946       };
82947     } catch (std::exception& e) {
82948       {
82949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82950       };
82951     } catch (...) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82954       };
82955     }
82956   }
82957   jresult = result;
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82963   unsigned long jresult ;
82964   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82965   std::size_t result;
82966
82967   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82968   {
82969     try {
82970       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82978       };
82979     } catch (...) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82982       };
82983     }
82984   }
82985   jresult = (unsigned long)result;
82986   return jresult;
82987 }
82988
82989
82990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
82991   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82992   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82993
82994   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82995   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82996   {
82997     try {
82998       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
82999     } catch (std::out_of_range& e) {
83000       {
83001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83002       };
83003     } catch (std::exception& e) {
83004       {
83005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (...) {
83008       {
83009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83010       };
83011     }
83012   }
83013 }
83014
83015
83016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83017   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83018   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83019
83020   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83021   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83022   {
83023     try {
83024       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83025     } catch (std::out_of_range& e) {
83026       {
83027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83028       };
83029     } catch (std::exception& e) {
83030       {
83031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83032       };
83033     } catch (...) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83036       };
83037     }
83038   }
83039 }
83040
83041
83042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83043   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83044   Dali::Actor arg2 ;
83045   Dali::Actor arg3 ;
83046   Dali::Actor *argp2 ;
83047   Dali::Actor *argp3 ;
83048
83049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83050   argp2 = (Dali::Actor *)jarg2;
83051   if (!argp2) {
83052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83053     return ;
83054   }
83055   arg2 = *argp2;
83056   argp3 = (Dali::Actor *)jarg3;
83057   if (!argp3) {
83058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83059     return ;
83060   }
83061   arg3 = *argp3;
83062   {
83063     try {
83064       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83065     } catch (std::out_of_range& e) {
83066       {
83067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83068       };
83069     } catch (std::exception& e) {
83070       {
83071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83072       };
83073     } catch (...) {
83074       {
83075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83076       };
83077     }
83078   }
83079 }
83080
83081
83082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83083   void * jresult ;
83084   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83085
83086   {
83087     try {
83088       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83089     } catch (std::out_of_range& e) {
83090       {
83091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83092       };
83093     } catch (std::exception& e) {
83094       {
83095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (...) {
83098       {
83099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83100       };
83101     }
83102   }
83103   jresult = (void *)result;
83104   return jresult;
83105 }
83106
83107
83108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83109   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83110
83111   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83112   {
83113     try {
83114       delete arg1;
83115     } catch (std::out_of_range& e) {
83116       {
83117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83118       };
83119     } catch (std::exception& e) {
83120       {
83121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83122       };
83123     } catch (...) {
83124       {
83125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83126       };
83127     }
83128   }
83129 }
83130
83131
83132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83133   unsigned int jresult ;
83134   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83135   bool result;
83136
83137   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83138   {
83139     try {
83140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83141     } catch (std::out_of_range& e) {
83142       {
83143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83144       };
83145     } catch (std::exception& e) {
83146       {
83147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83148       };
83149     } catch (...) {
83150       {
83151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83152       };
83153     }
83154   }
83155   jresult = result;
83156   return jresult;
83157 }
83158
83159
83160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83161   unsigned long jresult ;
83162   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83163   std::size_t result;
83164
83165   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83166   {
83167     try {
83168       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83169     } catch (std::out_of_range& e) {
83170       {
83171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83172       };
83173     } catch (std::exception& e) {
83174       {
83175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83176       };
83177     } catch (...) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83180       };
83181     }
83182   }
83183   jresult = (unsigned long)result;
83184   return jresult;
83185 }
83186
83187
83188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83189   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83190   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83191
83192   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83193   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83194   {
83195     try {
83196       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83197     } catch (std::out_of_range& e) {
83198       {
83199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83200       };
83201     } catch (std::exception& e) {
83202       {
83203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83204       };
83205     } catch (...) {
83206       {
83207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83208       };
83209     }
83210   }
83211 }
83212
83213
83214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83215   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83216   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83217
83218   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83219   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83220   {
83221     try {
83222       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83223     } catch (std::out_of_range& e) {
83224       {
83225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83226       };
83227     } catch (std::exception& e) {
83228       {
83229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83230       };
83231     } catch (...) {
83232       {
83233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83234       };
83235     }
83236   }
83237 }
83238
83239
83240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83241   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83242   Dali::Actor arg2 ;
83243   bool arg3 ;
83244   Dali::Actor *argp2 ;
83245
83246   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83247   argp2 = (Dali::Actor *)jarg2;
83248   if (!argp2) {
83249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83250     return ;
83251   }
83252   arg2 = *argp2;
83253   arg3 = jarg3 ? true : false;
83254   {
83255     try {
83256       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83257     } catch (std::out_of_range& e) {
83258       {
83259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83260       };
83261     } catch (std::exception& e) {
83262       {
83263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83264       };
83265     } catch (...) {
83266       {
83267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83268       };
83269     }
83270   }
83271 }
83272
83273
83274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83275   void * jresult ;
83276   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83277
83278   {
83279     try {
83280       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83281     } catch (std::out_of_range& e) {
83282       {
83283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (std::exception& e) {
83286       {
83287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83292       };
83293     }
83294   }
83295   jresult = (void *)result;
83296   return jresult;
83297 }
83298
83299
83300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83301   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83302
83303   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83304   {
83305     try {
83306       delete arg1;
83307     } catch (std::out_of_range& e) {
83308       {
83309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83310       };
83311     } catch (std::exception& e) {
83312       {
83313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83314       };
83315     } catch (...) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83318       };
83319     }
83320   }
83321 }
83322
83323
83324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83325   unsigned int jresult ;
83326   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83327   bool result;
83328
83329   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83330   {
83331     try {
83332       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);
83333     } catch (std::out_of_range& e) {
83334       {
83335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83336       };
83337     } catch (std::exception& e) {
83338       {
83339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (...) {
83342       {
83343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83344       };
83345     }
83346   }
83347   jresult = result;
83348   return jresult;
83349 }
83350
83351
83352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83353   unsigned long jresult ;
83354   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83355   std::size_t result;
83356
83357   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83358   {
83359     try {
83360       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);
83361     } catch (std::out_of_range& e) {
83362       {
83363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (std::exception& e) {
83366       {
83367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83368       };
83369     } catch (...) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83372       };
83373     }
83374   }
83375   jresult = (unsigned long)result;
83376   return jresult;
83377 }
83378
83379
83380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83381   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83382   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83383
83384   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83385   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83386   {
83387     try {
83388       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83389     } catch (std::out_of_range& e) {
83390       {
83391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83392       };
83393     } catch (std::exception& e) {
83394       {
83395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83396       };
83397     } catch (...) {
83398       {
83399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83400       };
83401     }
83402   }
83403 }
83404
83405
83406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83407   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83408   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83409
83410   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83411   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83412   {
83413     try {
83414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83415     } catch (std::out_of_range& e) {
83416       {
83417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83418       };
83419     } catch (std::exception& e) {
83420       {
83421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83422       };
83423     } catch (...) {
83424       {
83425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83426       };
83427     }
83428   }
83429 }
83430
83431
83432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83433   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83434   Dali::Toolkit::StyleManager arg2 ;
83435   Dali::StyleChange::Type arg3 ;
83436   Dali::Toolkit::StyleManager *argp2 ;
83437
83438   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83439   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83440   if (!argp2) {
83441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83442     return ;
83443   }
83444   arg2 = *argp2;
83445   arg3 = (Dali::StyleChange::Type)jarg3;
83446   {
83447     try {
83448       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83449     } catch (std::out_of_range& e) {
83450       {
83451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83452       };
83453     } catch (std::exception& e) {
83454       {
83455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83460       };
83461     }
83462   }
83463 }
83464
83465
83466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83467   void * jresult ;
83468   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83469
83470   {
83471     try {
83472       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83473     } catch (std::out_of_range& e) {
83474       {
83475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83476       };
83477     } catch (std::exception& e) {
83478       {
83479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83480       };
83481     } catch (...) {
83482       {
83483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83484       };
83485     }
83486   }
83487   jresult = (void *)result;
83488   return jresult;
83489 }
83490
83491
83492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83493   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83494
83495   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83496   {
83497     try {
83498       delete arg1;
83499     } catch (std::out_of_range& e) {
83500       {
83501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83502       };
83503     } catch (std::exception& e) {
83504       {
83505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83506       };
83507     } catch (...) {
83508       {
83509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83510       };
83511     }
83512   }
83513 }
83514
83515
83516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83517   unsigned int jresult ;
83518   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83519   bool result;
83520
83521   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83522   {
83523     try {
83524       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83525     } catch (std::out_of_range& e) {
83526       {
83527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83528       };
83529     } catch (std::exception& e) {
83530       {
83531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (...) {
83534       {
83535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83536       };
83537     }
83538   }
83539   jresult = result;
83540   return jresult;
83541 }
83542
83543
83544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83545   unsigned long jresult ;
83546   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83547   std::size_t result;
83548
83549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83550   {
83551     try {
83552       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83553     } catch (std::out_of_range& e) {
83554       {
83555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83556       };
83557     } catch (std::exception& e) {
83558       {
83559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (...) {
83562       {
83563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83564       };
83565     }
83566   }
83567   jresult = (unsigned long)result;
83568   return jresult;
83569 }
83570
83571
83572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83573   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83574   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83575
83576   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83577   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83578   {
83579     try {
83580       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (...) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83592       };
83593     }
83594   }
83595 }
83596
83597
83598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83599   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83600   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83601
83602   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83603   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83604   {
83605     try {
83606       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83607     } catch (std::out_of_range& e) {
83608       {
83609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83610       };
83611     } catch (std::exception& e) {
83612       {
83613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83614       };
83615     } catch (...) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83618       };
83619     }
83620   }
83621 }
83622
83623
83624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83625   unsigned int jresult ;
83626   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83627   Dali::Toolkit::Button arg2 ;
83628   Dali::Toolkit::Button *argp2 ;
83629   bool result;
83630
83631   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83632   argp2 = (Dali::Toolkit::Button *)jarg2;
83633   if (!argp2) {
83634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83635     return 0;
83636   }
83637   arg2 = *argp2;
83638   {
83639     try {
83640       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83641     } catch (std::out_of_range& e) {
83642       {
83643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83644       };
83645     } catch (std::exception& e) {
83646       {
83647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (...) {
83650       {
83651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83652       };
83653     }
83654   }
83655   jresult = result;
83656   return jresult;
83657 }
83658
83659
83660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83661   void * jresult ;
83662   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83663
83664   {
83665     try {
83666       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83667     } catch (std::out_of_range& e) {
83668       {
83669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83670       };
83671     } catch (std::exception& e) {
83672       {
83673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (...) {
83676       {
83677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83678       };
83679     }
83680   }
83681   jresult = (void *)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83687   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83688
83689   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83690   {
83691     try {
83692       delete arg1;
83693     } catch (std::out_of_range& e) {
83694       {
83695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83696       };
83697     } catch (std::exception& e) {
83698       {
83699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83700       };
83701     } catch (...) {
83702       {
83703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83704       };
83705     }
83706   }
83707 }
83708
83709
83710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83711   unsigned int jresult ;
83712   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83713   bool result;
83714
83715   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83716   {
83717     try {
83718       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83719     } catch (std::out_of_range& e) {
83720       {
83721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83722       };
83723     } catch (std::exception& e) {
83724       {
83725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83726       };
83727     } catch (...) {
83728       {
83729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83730       };
83731     }
83732   }
83733   jresult = result;
83734   return jresult;
83735 }
83736
83737
83738 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83739   unsigned long jresult ;
83740   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83741   std::size_t result;
83742
83743   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83744   {
83745     try {
83746       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83747     } catch (std::out_of_range& e) {
83748       {
83749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83750       };
83751     } catch (std::exception& e) {
83752       {
83753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83754       };
83755     } catch (...) {
83756       {
83757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83758       };
83759     }
83760   }
83761   jresult = (unsigned long)result;
83762   return jresult;
83763 }
83764
83765
83766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83767   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83768   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83769
83770   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83771   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83772   {
83773     try {
83774       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83775     } catch (std::out_of_range& e) {
83776       {
83777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83778       };
83779     } catch (std::exception& e) {
83780       {
83781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83782       };
83783     } catch (...) {
83784       {
83785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83786       };
83787     }
83788   }
83789 }
83790
83791
83792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83793   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83794   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83795
83796   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83797   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83798   {
83799     try {
83800       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83801     } catch (std::out_of_range& e) {
83802       {
83803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83804       };
83805     } catch (std::exception& e) {
83806       {
83807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83808       };
83809     } catch (...) {
83810       {
83811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83812       };
83813     }
83814   }
83815 }
83816
83817
83818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83819   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83820   Dali::Toolkit::GaussianBlurView arg2 ;
83821   Dali::Toolkit::GaussianBlurView *argp2 ;
83822
83823   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83824   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83825   if (!argp2) {
83826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83827     return ;
83828   }
83829   arg2 = *argp2;
83830   {
83831     try {
83832       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83844       };
83845     }
83846   }
83847 }
83848
83849
83850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83851   void * jresult ;
83852   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83853
83854   {
83855     try {
83856       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83857     } catch (std::out_of_range& e) {
83858       {
83859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (std::exception& e) {
83862       {
83863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83864       };
83865     } catch (...) {
83866       {
83867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83868       };
83869     }
83870   }
83871   jresult = (void *)result;
83872   return jresult;
83873 }
83874
83875
83876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83877   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83878
83879   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83880   {
83881     try {
83882       delete arg1;
83883     } catch (std::out_of_range& e) {
83884       {
83885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83886       };
83887     } catch (std::exception& e) {
83888       {
83889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83890       };
83891     } catch (...) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83894       };
83895     }
83896   }
83897 }
83898
83899
83900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83901   unsigned int jresult ;
83902   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83903   bool result;
83904
83905   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83906   {
83907     try {
83908       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);
83909     } catch (std::out_of_range& e) {
83910       {
83911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83912       };
83913     } catch (std::exception& e) {
83914       {
83915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (...) {
83918       {
83919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83920       };
83921     }
83922   }
83923   jresult = result;
83924   return jresult;
83925 }
83926
83927
83928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83929   unsigned long jresult ;
83930   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83931   std::size_t result;
83932
83933   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83934   {
83935     try {
83936       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);
83937     } catch (std::out_of_range& e) {
83938       {
83939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (std::exception& e) {
83942       {
83943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83948       };
83949     }
83950   }
83951   jresult = (unsigned long)result;
83952   return jresult;
83953 }
83954
83955
83956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83957   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83958   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83959
83960   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83961   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83962   {
83963     try {
83964       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83965     } catch (std::out_of_range& e) {
83966       {
83967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83968       };
83969     } catch (std::exception& e) {
83970       {
83971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83972       };
83973     } catch (...) {
83974       {
83975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83976       };
83977     }
83978   }
83979 }
83980
83981
83982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
83983   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83984   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83985
83986   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83987   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83988   {
83989     try {
83990       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83991     } catch (std::out_of_range& e) {
83992       {
83993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83994       };
83995     } catch (std::exception& e) {
83996       {
83997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83998       };
83999     } catch (...) {
84000       {
84001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84002       };
84003     }
84004   }
84005 }
84006
84007
84008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
84009   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84010   Dali::Toolkit::PageTurnView arg2 ;
84011   unsigned int arg3 ;
84012   bool arg4 ;
84013   Dali::Toolkit::PageTurnView *argp2 ;
84014
84015   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84016   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84017   if (!argp2) {
84018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84019     return ;
84020   }
84021   arg2 = *argp2;
84022   arg3 = (unsigned int)jarg3;
84023   arg4 = jarg4 ? true : false;
84024   {
84025     try {
84026       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84027     } catch (std::out_of_range& e) {
84028       {
84029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84030       };
84031     } catch (std::exception& e) {
84032       {
84033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84034       };
84035     } catch (...) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84038       };
84039     }
84040   }
84041 }
84042
84043
84044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84045   void * jresult ;
84046   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84047
84048   {
84049     try {
84050       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84051     } catch (std::out_of_range& e) {
84052       {
84053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84054       };
84055     } catch (std::exception& e) {
84056       {
84057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84058       };
84059     } catch (...) {
84060       {
84061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84062       };
84063     }
84064   }
84065   jresult = (void *)result;
84066   return jresult;
84067 }
84068
84069
84070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84071   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84072
84073   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84074   {
84075     try {
84076       delete arg1;
84077     } catch (std::out_of_range& e) {
84078       {
84079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84080       };
84081     } catch (std::exception& e) {
84082       {
84083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84084       };
84085     } catch (...) {
84086       {
84087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84088       };
84089     }
84090   }
84091 }
84092
84093
84094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84095   unsigned int jresult ;
84096   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84097   bool result;
84098
84099   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84100   {
84101     try {
84102       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84103     } catch (std::out_of_range& e) {
84104       {
84105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84106       };
84107     } catch (std::exception& e) {
84108       {
84109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84110       };
84111     } catch (...) {
84112       {
84113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84114       };
84115     }
84116   }
84117   jresult = result;
84118   return jresult;
84119 }
84120
84121
84122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84123   unsigned long jresult ;
84124   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84125   std::size_t result;
84126
84127   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84128   {
84129     try {
84130       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84138       };
84139     } catch (...) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84142       };
84143     }
84144   }
84145   jresult = (unsigned long)result;
84146   return jresult;
84147 }
84148
84149
84150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84151   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84152   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84153
84154   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84155   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84156   {
84157     try {
84158       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84166       };
84167     } catch (...) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84170       };
84171     }
84172   }
84173 }
84174
84175
84176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84177   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84178   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84179
84180   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84181   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84182   {
84183     try {
84184       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84185     } catch (std::out_of_range& e) {
84186       {
84187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (std::exception& e) {
84190       {
84191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84196       };
84197     }
84198   }
84199 }
84200
84201
84202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84203   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84204   Dali::Toolkit::PageTurnView arg2 ;
84205   Dali::Toolkit::PageTurnView *argp2 ;
84206
84207   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84208   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84209   if (!argp2) {
84210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84211     return ;
84212   }
84213   arg2 = *argp2;
84214   {
84215     try {
84216       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84228       };
84229     }
84230   }
84231 }
84232
84233
84234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84235   void * jresult ;
84236   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84237
84238   {
84239     try {
84240       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84241     } catch (std::out_of_range& e) {
84242       {
84243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84244       };
84245     } catch (std::exception& e) {
84246       {
84247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (...) {
84250       {
84251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84252       };
84253     }
84254   }
84255   jresult = (void *)result;
84256   return jresult;
84257 }
84258
84259
84260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84261   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84262
84263   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84264   {
84265     try {
84266       delete arg1;
84267     } catch (std::out_of_range& e) {
84268       {
84269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (std::exception& e) {
84272       {
84273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84274       };
84275     } catch (...) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84278       };
84279     }
84280   }
84281 }
84282
84283
84284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84285   unsigned int jresult ;
84286   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84287   bool result;
84288
84289   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84290   {
84291     try {
84292       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);
84293     } catch (std::out_of_range& e) {
84294       {
84295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (std::exception& e) {
84298       {
84299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84300       };
84301     } catch (...) {
84302       {
84303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84304       };
84305     }
84306   }
84307   jresult = result;
84308   return jresult;
84309 }
84310
84311
84312 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84313   unsigned long jresult ;
84314   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84315   std::size_t result;
84316
84317   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84318   {
84319     try {
84320       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);
84321     } catch (std::out_of_range& e) {
84322       {
84323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84324       };
84325     } catch (std::exception& e) {
84326       {
84327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84328       };
84329     } catch (...) {
84330       {
84331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84332       };
84333     }
84334   }
84335   jresult = (unsigned long)result;
84336   return jresult;
84337 }
84338
84339
84340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84341   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84342   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84343
84344   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84345   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84346   {
84347     try {
84348       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84360       };
84361     }
84362   }
84363 }
84364
84365
84366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84367   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84368   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84369
84370   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84371   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84372   {
84373     try {
84374       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84375     } catch (std::out_of_range& e) {
84376       {
84377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84378       };
84379     } catch (std::exception& e) {
84380       {
84381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84382       };
84383     } catch (...) {
84384       {
84385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84386       };
84387     }
84388   }
84389 }
84390
84391
84392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84393   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84394   Dali::Toolkit::ProgressBar arg2 ;
84395   float arg3 ;
84396   float arg4 ;
84397   Dali::Toolkit::ProgressBar *argp2 ;
84398
84399   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84400   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84401   if (!argp2) {
84402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84403     return ;
84404   }
84405   arg2 = *argp2;
84406   arg3 = (float)jarg3;
84407   arg4 = (float)jarg4;
84408   {
84409     try {
84410       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84418       };
84419     } catch (...) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84422       };
84423     }
84424   }
84425 }
84426
84427
84428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84429   void * jresult ;
84430   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84431
84432   {
84433     try {
84434       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84446       };
84447     }
84448   }
84449   jresult = (void *)result;
84450   return jresult;
84451 }
84452
84453
84454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84455   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84456
84457   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84458   {
84459     try {
84460       delete arg1;
84461     } catch (std::out_of_range& e) {
84462       {
84463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84464       };
84465     } catch (std::exception& e) {
84466       {
84467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84468       };
84469     } catch (...) {
84470       {
84471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84472       };
84473     }
84474   }
84475 }
84476
84477
84478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84479   unsigned int jresult ;
84480   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84481   bool result;
84482
84483   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84484   {
84485     try {
84486       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);
84487     } catch (std::out_of_range& e) {
84488       {
84489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84490       };
84491     } catch (std::exception& e) {
84492       {
84493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (...) {
84496       {
84497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84498       };
84499     }
84500   }
84501   jresult = result;
84502   return jresult;
84503 }
84504
84505
84506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84507   unsigned long jresult ;
84508   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84509   std::size_t result;
84510
84511   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84512   {
84513     try {
84514       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);
84515     } catch (std::out_of_range& e) {
84516       {
84517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84518       };
84519     } catch (std::exception& e) {
84520       {
84521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84522       };
84523     } catch (...) {
84524       {
84525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84526       };
84527     }
84528   }
84529   jresult = (unsigned long)result;
84530   return jresult;
84531 }
84532
84533
84534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84535   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84536   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84537
84538   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84539   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84540   {
84541     try {
84542       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84550       };
84551     } catch (...) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84554       };
84555     }
84556   }
84557 }
84558
84559
84560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84561   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84562   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84563
84564   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84565   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84566   {
84567     try {
84568       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84580       };
84581     }
84582   }
84583 }
84584
84585
84586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84587   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84588   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84589
84590   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84591   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84592   if (!arg2) {
84593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84594     return ;
84595   }
84596   {
84597     try {
84598       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84606       };
84607     } catch (...) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84610       };
84611     }
84612   }
84613 }
84614
84615
84616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84617   void * jresult ;
84618   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84619
84620   {
84621     try {
84622       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84623     } catch (std::out_of_range& e) {
84624       {
84625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84626       };
84627     } catch (std::exception& e) {
84628       {
84629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (...) {
84632       {
84633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84634       };
84635     }
84636   }
84637   jresult = (void *)result;
84638   return jresult;
84639 }
84640
84641
84642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84643   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84644
84645   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84646   {
84647     try {
84648       delete arg1;
84649     } catch (std::out_of_range& e) {
84650       {
84651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84652       };
84653     } catch (std::exception& e) {
84654       {
84655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84660       };
84661     }
84662   }
84663 }
84664
84665
84666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84667   unsigned int jresult ;
84668   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84669   bool result;
84670
84671   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84672   {
84673     try {
84674       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (...) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84686       };
84687     }
84688   }
84689   jresult = result;
84690   return jresult;
84691 }
84692
84693
84694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84695   unsigned long jresult ;
84696   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84697   std::size_t result;
84698
84699   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84700   {
84701     try {
84702       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84703     } catch (std::out_of_range& e) {
84704       {
84705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (std::exception& e) {
84708       {
84709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (...) {
84712       {
84713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84714       };
84715     }
84716   }
84717   jresult = (unsigned long)result;
84718   return jresult;
84719 }
84720
84721
84722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84723   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84724   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84725
84726   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84727   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84728   {
84729     try {
84730       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84731     } catch (std::out_of_range& e) {
84732       {
84733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84734       };
84735     } catch (std::exception& e) {
84736       {
84737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84738       };
84739     } catch (...) {
84740       {
84741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84742       };
84743     }
84744   }
84745 }
84746
84747
84748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84749   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84750   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84751
84752   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84753   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84754   {
84755     try {
84756       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84757     } catch (std::out_of_range& e) {
84758       {
84759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84760       };
84761     } catch (std::exception& e) {
84762       {
84763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84764       };
84765     } catch (...) {
84766       {
84767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84768       };
84769     }
84770   }
84771 }
84772
84773
84774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84775   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84776   Dali::Vector2 *arg2 = 0 ;
84777
84778   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84779   arg2 = (Dali::Vector2 *)jarg2;
84780   if (!arg2) {
84781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84782     return ;
84783   }
84784   {
84785     try {
84786       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84794       };
84795     } catch (...) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84798       };
84799     }
84800   }
84801 }
84802
84803
84804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84805   void * jresult ;
84806   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84807
84808   {
84809     try {
84810       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (...) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84822       };
84823     }
84824   }
84825   jresult = (void *)result;
84826   return jresult;
84827 }
84828
84829
84830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84831   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84832
84833   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84834   {
84835     try {
84836       delete arg1;
84837     } catch (std::out_of_range& e) {
84838       {
84839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84840       };
84841     } catch (std::exception& e) {
84842       {
84843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84844       };
84845     } catch (...) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84848       };
84849     }
84850   }
84851 }
84852
84853
84854
84855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84856   unsigned int jresult ;
84857   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84858   bool result;
84859
84860   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84861   {
84862     try {
84863       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);
84864     } catch (std::out_of_range& e) {
84865       {
84866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84867       };
84868     } catch (std::exception& e) {
84869       {
84870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84871       };
84872     } catch (...) {
84873       {
84874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84875       };
84876     }
84877   }
84878   jresult = result;
84879   return jresult;
84880 }
84881
84882
84883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84884   unsigned long jresult ;
84885   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84886   std::size_t result;
84887
84888   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84889   {
84890     try {
84891       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);
84892     } catch (std::out_of_range& e) {
84893       {
84894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84895       };
84896     } catch (std::exception& e) {
84897       {
84898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84899       };
84900     } catch (...) {
84901       {
84902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84903       };
84904     }
84905   }
84906   jresult = (unsigned long)result;
84907   return jresult;
84908 }
84909
84910
84911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84912   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84913   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84914
84915   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84916   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84917   {
84918     try {
84919       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84920     } catch (std::out_of_range& e) {
84921       {
84922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84923       };
84924     } catch (std::exception& e) {
84925       {
84926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84927       };
84928     } catch (...) {
84929       {
84930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84931       };
84932     }
84933   }
84934 }
84935
84936
84937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84938   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84939   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84940
84941   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84942   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84943   {
84944     try {
84945       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84946     } catch (std::out_of_range& e) {
84947       {
84948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84949       };
84950     } catch (std::exception& e) {
84951       {
84952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84953       };
84954     } catch (...) {
84955       {
84956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84957       };
84958     }
84959   }
84960 }
84961
84962
84963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84964   unsigned int jresult ;
84965   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84966   Dali::Toolkit::Control arg2 ;
84967   Dali::KeyEvent *arg3 = 0 ;
84968   Dali::Toolkit::Control *argp2 ;
84969   bool result;
84970
84971   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84972   argp2 = (Dali::Toolkit::Control *)jarg2;
84973   if (!argp2) {
84974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84975     return 0;
84976   }
84977   arg2 = *argp2;
84978   arg3 = (Dali::KeyEvent *)jarg3;
84979   if (!arg3) {
84980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
84981     return 0;
84982   }
84983   {
84984     try {
84985       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);
84986     } catch (std::out_of_range& e) {
84987       {
84988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (std::exception& e) {
84991       {
84992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84993       };
84994     } catch (...) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84997       };
84998     }
84999   }
85000   jresult = result;
85001   return jresult;
85002 }
85003
85004
85005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
85006   void * jresult ;
85007   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
85008
85009   {
85010     try {
85011       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
85012     } catch (std::out_of_range& e) {
85013       {
85014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85015       };
85016     } catch (std::exception& e) {
85017       {
85018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85019       };
85020     } catch (...) {
85021       {
85022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85023       };
85024     }
85025   }
85026   jresult = (void *)result;
85027   return jresult;
85028 }
85029
85030
85031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85032   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85033
85034   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85035   {
85036     try {
85037       delete arg1;
85038     } catch (std::out_of_range& e) {
85039       {
85040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85041       };
85042     } catch (std::exception& e) {
85043       {
85044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85045       };
85046     } catch (...) {
85047       {
85048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85049       };
85050     }
85051   }
85052 }
85053
85054
85055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85056   unsigned int jresult ;
85057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85058   bool result;
85059
85060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85061   {
85062     try {
85063       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85064     } catch (std::out_of_range& e) {
85065       {
85066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85067       };
85068     } catch (std::exception& e) {
85069       {
85070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85071       };
85072     } catch (...) {
85073       {
85074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85075       };
85076     }
85077   }
85078   jresult = result;
85079   return jresult;
85080 }
85081
85082
85083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85084   unsigned long jresult ;
85085   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85086   std::size_t result;
85087
85088   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85089   {
85090     try {
85091       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85092     } catch (std::out_of_range& e) {
85093       {
85094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85095       };
85096     } catch (std::exception& e) {
85097       {
85098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85099       };
85100     } catch (...) {
85101       {
85102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85103       };
85104     }
85105   }
85106   jresult = (unsigned long)result;
85107   return jresult;
85108 }
85109
85110
85111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85112   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85113   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85114
85115   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85116   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85117   {
85118     try {
85119       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85120     } catch (std::out_of_range& e) {
85121       {
85122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85123       };
85124     } catch (std::exception& e) {
85125       {
85126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85127       };
85128     } catch (...) {
85129       {
85130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85131       };
85132     }
85133   }
85134 }
85135
85136
85137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85138   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85139   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85140
85141   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85142   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85143   {
85144     try {
85145       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85146     } catch (std::out_of_range& e) {
85147       {
85148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85149       };
85150     } catch (std::exception& e) {
85151       {
85152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85153       };
85154     } catch (...) {
85155       {
85156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85157       };
85158     }
85159   }
85160 }
85161
85162
85163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85164   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85165   Dali::Toolkit::Control arg2 ;
85166   Dali::Toolkit::Control *argp2 ;
85167
85168   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85169   argp2 = (Dali::Toolkit::Control *)jarg2;
85170   if (!argp2) {
85171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85172     return ;
85173   }
85174   arg2 = *argp2;
85175   {
85176     try {
85177       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85178     } catch (std::out_of_range& e) {
85179       {
85180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85181       };
85182     } catch (std::exception& e) {
85183       {
85184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85189       };
85190     }
85191   }
85192 }
85193
85194
85195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85196   void * jresult ;
85197   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85198
85199   {
85200     try {
85201       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85202     } catch (std::out_of_range& e) {
85203       {
85204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (std::exception& e) {
85207       {
85208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (...) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85213       };
85214     }
85215   }
85216   jresult = (void *)result;
85217   return jresult;
85218 }
85219
85220
85221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85222   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85223
85224   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85225   {
85226     try {
85227       delete arg1;
85228     } catch (std::out_of_range& e) {
85229       {
85230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85231       };
85232     } catch (std::exception& e) {
85233       {
85234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85235       };
85236     } catch (...) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85239       };
85240     }
85241   }
85242 }
85243
85244
85245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85246   unsigned int jresult ;
85247   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85248   bool result;
85249
85250   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85251   {
85252     try {
85253       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85254     } catch (std::out_of_range& e) {
85255       {
85256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85257       };
85258     } catch (std::exception& e) {
85259       {
85260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85261       };
85262     } catch (...) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85265       };
85266     }
85267   }
85268   jresult = result;
85269   return jresult;
85270 }
85271
85272
85273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85274   unsigned long jresult ;
85275   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85276   std::size_t result;
85277
85278   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85279   {
85280     try {
85281       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85282     } catch (std::out_of_range& e) {
85283       {
85284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85285       };
85286     } catch (std::exception& e) {
85287       {
85288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85289       };
85290     } catch (...) {
85291       {
85292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85293       };
85294     }
85295   }
85296   jresult = (unsigned long)result;
85297   return jresult;
85298 }
85299
85300
85301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85302   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85303   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85304
85305   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85306   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85307   {
85308     try {
85309       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85317       };
85318     } catch (...) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85321       };
85322     }
85323   }
85324 }
85325
85326
85327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85328   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85329   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85330
85331   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85332   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85333   {
85334     try {
85335       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85336     } catch (std::out_of_range& e) {
85337       {
85338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (std::exception& e) {
85341       {
85342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85343       };
85344     } catch (...) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85347       };
85348     }
85349   }
85350 }
85351
85352
85353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85354   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85355   Dali::Toolkit::VideoView *arg2 = 0 ;
85356
85357   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85358   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85359   if (!arg2) {
85360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85361     return ;
85362   }
85363   {
85364     try {
85365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85366     } catch (std::out_of_range& e) {
85367       {
85368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85369       };
85370     } catch (std::exception& e) {
85371       {
85372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85373       };
85374     } catch (...) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85377       };
85378     }
85379   }
85380 }
85381
85382
85383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85384   void * jresult ;
85385   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85386
85387   {
85388     try {
85389       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85390     } catch (std::out_of_range& e) {
85391       {
85392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85393       };
85394     } catch (std::exception& e) {
85395       {
85396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85397       };
85398     } catch (...) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85401       };
85402     }
85403   }
85404   jresult = (void *)result;
85405   return jresult;
85406 }
85407
85408
85409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85410   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85411
85412   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85413   {
85414     try {
85415       delete arg1;
85416     } catch (std::out_of_range& e) {
85417       {
85418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85419       };
85420     } catch (std::exception& e) {
85421       {
85422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85423       };
85424     } catch (...) {
85425       {
85426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85427       };
85428     }
85429   }
85430 }
85431
85432
85433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85434   unsigned int jresult ;
85435   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85436   bool result;
85437
85438   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85439   {
85440     try {
85441       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85442     } catch (std::out_of_range& e) {
85443       {
85444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85445       };
85446     } catch (std::exception& e) {
85447       {
85448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85449       };
85450     } catch (...) {
85451       {
85452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85453       };
85454     }
85455   }
85456   jresult = result;
85457   return jresult;
85458 }
85459
85460
85461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85462   unsigned long jresult ;
85463   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85464   std::size_t result;
85465
85466   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85467   {
85468     try {
85469       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85470     } catch (std::out_of_range& e) {
85471       {
85472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85473       };
85474     } catch (std::exception& e) {
85475       {
85476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85477       };
85478     } catch (...) {
85479       {
85480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85481       };
85482     }
85483   }
85484   jresult = (unsigned long)result;
85485   return jresult;
85486 }
85487
85488
85489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85490   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85491   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85492
85493   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85494   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85495   {
85496     try {
85497       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85498     } catch (std::out_of_range& e) {
85499       {
85500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85501       };
85502     } catch (std::exception& e) {
85503       {
85504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85509       };
85510     }
85511   }
85512 }
85513
85514
85515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85516   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85517   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85518
85519   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85520   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85521   {
85522     try {
85523       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85524     } catch (std::out_of_range& e) {
85525       {
85526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85527       };
85528     } catch (std::exception& e) {
85529       {
85530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85535       };
85536     }
85537   }
85538 }
85539
85540
85541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85542   unsigned int jresult ;
85543   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85544   Dali::Toolkit::Slider arg2 ;
85545   float arg3 ;
85546   Dali::Toolkit::Slider *argp2 ;
85547   bool result;
85548
85549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85550   argp2 = (Dali::Toolkit::Slider *)jarg2;
85551   if (!argp2) {
85552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85553     return 0;
85554   }
85555   arg2 = *argp2;
85556   arg3 = (float)jarg3;
85557   {
85558     try {
85559       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85560     } catch (std::out_of_range& e) {
85561       {
85562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (std::exception& e) {
85565       {
85566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (...) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85571       };
85572     }
85573   }
85574   jresult = result;
85575   return jresult;
85576 }
85577
85578
85579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85580   void * jresult ;
85581   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85582
85583   {
85584     try {
85585       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85586     } catch (std::out_of_range& e) {
85587       {
85588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85589       };
85590     } catch (std::exception& e) {
85591       {
85592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85593       };
85594     } catch (...) {
85595       {
85596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85597       };
85598     }
85599   }
85600   jresult = (void *)result;
85601   return jresult;
85602 }
85603
85604
85605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85606   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85607
85608   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85609   {
85610     try {
85611       delete arg1;
85612     } catch (std::out_of_range& e) {
85613       {
85614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85615       };
85616     } catch (std::exception& e) {
85617       {
85618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85619       };
85620     } catch (...) {
85621       {
85622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85623       };
85624     }
85625   }
85626 }
85627
85628
85629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85630   unsigned int jresult ;
85631   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85632   bool result;
85633
85634   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85635   {
85636     try {
85637       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85638     } catch (std::out_of_range& e) {
85639       {
85640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85641       };
85642     } catch (std::exception& e) {
85643       {
85644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85645       };
85646     } catch (...) {
85647       {
85648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85649       };
85650     }
85651   }
85652   jresult = result;
85653   return jresult;
85654 }
85655
85656
85657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85658   unsigned long jresult ;
85659   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85660   std::size_t result;
85661
85662   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85663   {
85664     try {
85665       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85666     } catch (std::out_of_range& e) {
85667       {
85668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85669       };
85670     } catch (std::exception& e) {
85671       {
85672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85673       };
85674     } catch (...) {
85675       {
85676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85677       };
85678     }
85679   }
85680   jresult = (unsigned long)result;
85681   return jresult;
85682 }
85683
85684
85685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85686   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85687   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85688
85689   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85690   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85691   {
85692     try {
85693       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85694     } catch (std::out_of_range& e) {
85695       {
85696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85697       };
85698     } catch (std::exception& e) {
85699       {
85700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85701       };
85702     } catch (...) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85705       };
85706     }
85707   }
85708 }
85709
85710
85711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85712   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85713   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85714
85715   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85716   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85717   {
85718     try {
85719       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85720     } catch (std::out_of_range& e) {
85721       {
85722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85723       };
85724     } catch (std::exception& e) {
85725       {
85726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85731       };
85732     }
85733   }
85734 }
85735
85736
85737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85738   unsigned int jresult ;
85739   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85740   Dali::Toolkit::Slider arg2 ;
85741   int arg3 ;
85742   Dali::Toolkit::Slider *argp2 ;
85743   bool result;
85744
85745   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85746   argp2 = (Dali::Toolkit::Slider *)jarg2;
85747   if (!argp2) {
85748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85749     return 0;
85750   }
85751   arg2 = *argp2;
85752   arg3 = (int)jarg3;
85753   {
85754     try {
85755       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (...) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85767       };
85768     }
85769   }
85770   jresult = result;
85771   return jresult;
85772 }
85773
85774
85775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85776   void * jresult ;
85777   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85778
85779   {
85780     try {
85781       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85782     } catch (std::out_of_range& e) {
85783       {
85784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (std::exception& e) {
85787       {
85788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (...) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85793       };
85794     }
85795   }
85796   jresult = (void *)result;
85797   return jresult;
85798 }
85799
85800
85801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85802   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85803
85804   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85805   {
85806     try {
85807       delete arg1;
85808     } catch (std::out_of_range& e) {
85809       {
85810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85811       };
85812     } catch (std::exception& e) {
85813       {
85814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85815       };
85816     } catch (...) {
85817       {
85818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85819       };
85820     }
85821   }
85822 }
85823
85824
85825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85826   void * jresult ;
85827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85828
85829   {
85830     try {
85831       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85832     } catch (std::out_of_range& e) {
85833       {
85834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85835       };
85836     } catch (std::exception& e) {
85837       {
85838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85839       };
85840     } catch (...) {
85841       {
85842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85843       };
85844     }
85845   }
85846   jresult = (void *)result;
85847   return jresult;
85848 }
85849
85850
85851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85852   void * jresult ;
85853   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85854   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85855
85856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85857   {
85858     try {
85859       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85860     } catch (std::out_of_range& e) {
85861       {
85862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85863       };
85864     } catch (std::exception& e) {
85865       {
85866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85867       };
85868     } catch (...) {
85869       {
85870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85871       };
85872     }
85873   }
85874   jresult = (void *)result;
85875   return jresult;
85876 }
85877
85878
85879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85880   void * jresult ;
85881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85883
85884   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85885   if (!arg1) {
85886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85887     return 0;
85888   }
85889   {
85890     try {
85891       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85892     } catch (std::out_of_range& e) {
85893       {
85894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85895       };
85896     } catch (std::exception& e) {
85897       {
85898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85899       };
85900     } catch (...) {
85901       {
85902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85903       };
85904     }
85905   }
85906   jresult = (void *)result;
85907   return jresult;
85908 }
85909
85910
85911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85913
85914   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85915   {
85916     try {
85917       delete arg1;
85918     } catch (std::out_of_range& e) {
85919       {
85920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85921       };
85922     } catch (std::exception& e) {
85923       {
85924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85925       };
85926     } catch (...) {
85927       {
85928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85929       };
85930     }
85931   }
85932 }
85933
85934
85935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85936   void * jresult ;
85937   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85938   Dali::Toolkit::Ruler *result = 0 ;
85939
85940   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85941   {
85942     try {
85943       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
85944     } catch (std::out_of_range& e) {
85945       {
85946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85947       };
85948     } catch (std::exception& e) {
85949       {
85950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85951       };
85952     } catch (...) {
85953       {
85954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85955       };
85956     }
85957   }
85958   jresult = (void *)result;
85959   return jresult;
85960 }
85961
85962
85963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85964   void * jresult ;
85965   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85966   Dali::Toolkit::Ruler *result = 0 ;
85967
85968   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85969   {
85970     try {
85971       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85972     } catch (std::out_of_range& e) {
85973       {
85974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85975       };
85976     } catch (std::exception& e) {
85977       {
85978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (...) {
85981       {
85982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85983       };
85984     }
85985   }
85986   jresult = (void *)result;
85987   return jresult;
85988 }
85989
85990
85991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
85992   void * jresult ;
85993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85994   Dali::Toolkit::Ruler *result = 0 ;
85995
85996   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85997   {
85998     try {
85999       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (...) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86011       };
86012     }
86013   }
86014   jresult = (void *)result;
86015   return jresult;
86016 }
86017
86018
86019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
86020   void * jresult ;
86021   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
86023   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86024
86025   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86026   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86027   if (!arg2) {
86028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86029     return 0;
86030   }
86031   {
86032     try {
86033       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048   jresult = (void *)result;
86049   return jresult;
86050 }
86051
86052
86053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86054   void * jresult ;
86055   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86056   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86057   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86058
86059   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86060   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86061   {
86062     try {
86063       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86064     } catch (std::out_of_range& e) {
86065       {
86066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86067       };
86068     } catch (std::exception& e) {
86069       {
86070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86071       };
86072     } catch (...) {
86073       {
86074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86075       };
86076     }
86077   }
86078   jresult = (void *)result;
86079   return jresult;
86080 }
86081
86082
86083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86085
86086   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86087   {
86088     try {
86089       (arg1)->Reset();
86090     } catch (std::out_of_range& e) {
86091       {
86092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86093       };
86094     } catch (std::exception& e) {
86095       {
86096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86097       };
86098     } catch (...) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86101       };
86102     }
86103   }
86104 }
86105
86106
86107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86108   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86109   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86110
86111   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86112   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86113   {
86114     try {
86115       (arg1)->Reset(arg2);
86116     } catch (std::out_of_range& e) {
86117       {
86118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86119       };
86120     } catch (std::exception& e) {
86121       {
86122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86123       };
86124     } catch (...) {
86125       {
86126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86127       };
86128     }
86129   }
86130 }
86131
86132
86133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86134   void * jresult ;
86135   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86136   Dali::Toolkit::Ruler *result = 0 ;
86137
86138   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86139   {
86140     try {
86141       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86142     } catch (std::out_of_range& e) {
86143       {
86144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86145       };
86146     } catch (std::exception& e) {
86147       {
86148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86149       };
86150     } catch (...) {
86151       {
86152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86153       };
86154     }
86155   }
86156   jresult = (void *)result;
86157   return jresult;
86158 }
86159
86160
86161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86162   float jresult ;
86163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86164   float arg2 ;
86165   float arg3 ;
86166   float result;
86167
86168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86169   arg2 = (float)jarg2;
86170   arg3 = (float)jarg3;
86171   {
86172     try {
86173       result = (float)(*arg1)->Snap(arg2,arg3);
86174     } catch (std::out_of_range& e) {
86175       {
86176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86177       };
86178     } catch (std::exception& e) {
86179       {
86180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86181       };
86182     } catch (...) {
86183       {
86184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86185       };
86186     }
86187   }
86188   jresult = result;
86189   return jresult;
86190 }
86191
86192
86193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86194   float jresult ;
86195   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86196   float arg2 ;
86197   float result;
86198
86199   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86200   arg2 = (float)jarg2;
86201   {
86202     try {
86203       result = (float)(*arg1)->Snap(arg2);
86204     } catch (std::out_of_range& e) {
86205       {
86206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86207       };
86208     } catch (std::exception& e) {
86209       {
86210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86211       };
86212     } catch (...) {
86213       {
86214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86215       };
86216     }
86217   }
86218   jresult = result;
86219   return jresult;
86220 }
86221
86222
86223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86224   float jresult ;
86225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86226   unsigned int arg2 ;
86227   unsigned int *arg3 = 0 ;
86228   bool arg4 ;
86229   float result;
86230
86231   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86232   arg2 = (unsigned int)jarg2;
86233   arg3 = (unsigned int *)jarg3;
86234   arg4 = jarg4 ? true : false;
86235   {
86236     try {
86237       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86238     } catch (std::out_of_range& e) {
86239       {
86240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86241       };
86242     } catch (std::exception& e) {
86243       {
86244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86245       };
86246     } catch (...) {
86247       {
86248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86249       };
86250     }
86251   }
86252   jresult = result;
86253   return jresult;
86254 }
86255
86256
86257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86258   unsigned int jresult ;
86259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86260   float arg2 ;
86261   bool arg3 ;
86262   unsigned int result;
86263
86264   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86265   arg2 = (float)jarg2;
86266   arg3 = jarg3 ? true : false;
86267   {
86268     try {
86269       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86270     } catch (std::out_of_range& e) {
86271       {
86272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86273       };
86274     } catch (std::exception& e) {
86275       {
86276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86277       };
86278     } catch (...) {
86279       {
86280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86281       };
86282     }
86283   }
86284   jresult = result;
86285   return jresult;
86286 }
86287
86288
86289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86290   unsigned int jresult ;
86291   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86292   unsigned int result;
86293
86294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86295   {
86296     try {
86297       result = (unsigned int)(*arg1)->GetTotalPages();
86298     } catch (std::out_of_range& e) {
86299       {
86300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86301       };
86302     } catch (std::exception& e) {
86303       {
86304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86305       };
86306     } catch (...) {
86307       {
86308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86309       };
86310     }
86311   }
86312   jresult = result;
86313   return jresult;
86314 }
86315
86316
86317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86318   int jresult ;
86319   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86320   Dali::Toolkit::Ruler::RulerType result;
86321
86322   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86323   {
86324     try {
86325       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86326     } catch (std::out_of_range& e) {
86327       {
86328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86329       };
86330     } catch (std::exception& e) {
86331       {
86332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86333       };
86334     } catch (...) {
86335       {
86336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86337       };
86338     }
86339   }
86340   jresult = (int)result;
86341   return jresult;
86342 }
86343
86344
86345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86346   unsigned int jresult ;
86347   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86348   bool result;
86349
86350   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86351   {
86352     try {
86353       result = (bool)(*arg1)->IsEnabled();
86354     } catch (std::out_of_range& e) {
86355       {
86356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (std::exception& e) {
86359       {
86360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (...) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86365       };
86366     }
86367   }
86368   jresult = result;
86369   return jresult;
86370 }
86371
86372
86373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(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)->Enable();
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_Disable(void * jarg1) {
86398   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86399
86400   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86401   {
86402     try {
86403       (*arg1)->Disable();
86404     } catch (std::out_of_range& e) {
86405       {
86406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86407       };
86408     } catch (std::exception& e) {
86409       {
86410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86411       };
86412     } catch (...) {
86413       {
86414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86415       };
86416     }
86417   }
86418 }
86419
86420
86421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86422   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86423   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86424   Dali::Toolkit::RulerDomain *argp2 ;
86425
86426   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86427   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86428   if (!argp2) {
86429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86430     return ;
86431   }
86432   arg2 = *argp2;
86433   {
86434     try {
86435       (*arg1)->SetDomain(arg2);
86436     } catch (std::out_of_range& e) {
86437       {
86438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86439       };
86440     } catch (std::exception& e) {
86441       {
86442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86443       };
86444     } catch (...) {
86445       {
86446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86447       };
86448     }
86449   }
86450 }
86451
86452
86453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86454   void * jresult ;
86455   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86456   Dali::Toolkit::RulerDomain *result = 0 ;
86457
86458   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86459   {
86460     try {
86461       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86462     } catch (std::out_of_range& e) {
86463       {
86464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (std::exception& e) {
86467       {
86468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86469       };
86470     } catch (...) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86473       };
86474     }
86475   }
86476   jresult = (void *)result;
86477   return jresult;
86478 }
86479
86480
86481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86482   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86483
86484   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86485   {
86486     try {
86487       (*arg1)->DisableDomain();
86488     } catch (std::out_of_range& e) {
86489       {
86490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86491       };
86492     } catch (std::exception& e) {
86493       {
86494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86495       };
86496     } catch (...) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86499       };
86500     }
86501   }
86502 }
86503
86504
86505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86506   float jresult ;
86507   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86508   float arg2 ;
86509   float arg3 ;
86510   float arg4 ;
86511   float result;
86512
86513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86514   arg2 = (float)jarg2;
86515   arg3 = (float)jarg3;
86516   arg4 = (float)jarg4;
86517   {
86518     try {
86519       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86520     } catch (std::out_of_range& e) {
86521       {
86522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86523       };
86524     } catch (std::exception& e) {
86525       {
86526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (...) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86531       };
86532     }
86533   }
86534   jresult = result;
86535   return jresult;
86536 }
86537
86538
86539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86540   float jresult ;
86541   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86542   float arg2 ;
86543   float arg3 ;
86544   float result;
86545
86546   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86547   arg2 = (float)jarg2;
86548   arg3 = (float)jarg3;
86549   {
86550     try {
86551       result = (float)(*arg1)->Clamp(arg2,arg3);
86552     } catch (std::out_of_range& e) {
86553       {
86554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86555       };
86556     } catch (std::exception& e) {
86557       {
86558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86559       };
86560     } catch (...) {
86561       {
86562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86563       };
86564     }
86565   }
86566   jresult = result;
86567   return jresult;
86568 }
86569
86570
86571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86572   float jresult ;
86573   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86574   float arg2 ;
86575   float result;
86576
86577   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86578   arg2 = (float)jarg2;
86579   {
86580     try {
86581       result = (float)(*arg1)->Clamp(arg2);
86582     } catch (std::out_of_range& e) {
86583       {
86584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86585       };
86586     } catch (std::exception& e) {
86587       {
86588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86589       };
86590     } catch (...) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86593       };
86594     }
86595   }
86596   jresult = result;
86597   return jresult;
86598 }
86599
86600
86601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86602   float jresult ;
86603   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86604   float arg2 ;
86605   float arg3 ;
86606   float arg4 ;
86607   Dali::Toolkit::ClampState *arg5 = 0 ;
86608   float result;
86609
86610   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86611   arg2 = (float)jarg2;
86612   arg3 = (float)jarg3;
86613   arg4 = (float)jarg4;
86614   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86615   if (!arg5) {
86616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86617     return 0;
86618   }
86619   {
86620     try {
86621       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86622     } catch (std::out_of_range& e) {
86623       {
86624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86625       };
86626     } catch (std::exception& e) {
86627       {
86628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86629       };
86630     } catch (...) {
86631       {
86632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86633       };
86634     }
86635   }
86636   jresult = result;
86637   return jresult;
86638 }
86639
86640
86641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86642   float jresult ;
86643   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86644   float arg2 ;
86645   float arg3 ;
86646   float arg4 ;
86647   float arg5 ;
86648   float result;
86649
86650   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86651   arg2 = (float)jarg2;
86652   arg3 = (float)jarg3;
86653   arg4 = (float)jarg4;
86654   arg5 = (float)jarg5;
86655   {
86656     try {
86657       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86658     } catch (std::out_of_range& e) {
86659       {
86660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86661       };
86662     } catch (std::exception& e) {
86663       {
86664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (...) {
86667       {
86668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86669       };
86670     }
86671   }
86672   jresult = result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86678   float jresult ;
86679   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86680   float arg2 ;
86681   float arg3 ;
86682   float arg4 ;
86683   float result;
86684
86685   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86686   arg2 = (float)jarg2;
86687   arg3 = (float)jarg3;
86688   arg4 = (float)jarg4;
86689   {
86690     try {
86691       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86692     } catch (std::out_of_range& e) {
86693       {
86694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86695       };
86696     } catch (std::exception& e) {
86697       {
86698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86699       };
86700     } catch (...) {
86701       {
86702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86703       };
86704     }
86705   }
86706   jresult = result;
86707   return jresult;
86708 }
86709
86710
86711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86712   float jresult ;
86713   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86714   float arg2 ;
86715   float arg3 ;
86716   float result;
86717
86718   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86719   arg2 = (float)jarg2;
86720   arg3 = (float)jarg3;
86721   {
86722     try {
86723       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86724     } catch (std::out_of_range& e) {
86725       {
86726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (std::exception& e) {
86729       {
86730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (...) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86735       };
86736     }
86737   }
86738   jresult = result;
86739   return jresult;
86740 }
86741
86742
86743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86744   float jresult ;
86745   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86746   float arg2 ;
86747   float result;
86748
86749   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86750   arg2 = (float)jarg2;
86751   {
86752     try {
86753       result = (float)(*arg1)->SnapAndClamp(arg2);
86754     } catch (std::out_of_range& e) {
86755       {
86756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86757       };
86758     } catch (std::exception& e) {
86759       {
86760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86761       };
86762     } catch (...) {
86763       {
86764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86765       };
86766     }
86767   }
86768   jresult = result;
86769   return jresult;
86770 }
86771
86772
86773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86774   float jresult ;
86775   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86776   float arg2 ;
86777   float arg3 ;
86778   float arg4 ;
86779   float arg5 ;
86780   Dali::Toolkit::ClampState *arg6 = 0 ;
86781   float result;
86782
86783   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86784   arg2 = (float)jarg2;
86785   arg3 = (float)jarg3;
86786   arg4 = (float)jarg4;
86787   arg5 = (float)jarg5;
86788   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86789   if (!arg6) {
86790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86791     return 0;
86792   }
86793   {
86794     try {
86795       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86796     } catch (std::out_of_range& e) {
86797       {
86798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86799       };
86800     } catch (std::exception& e) {
86801       {
86802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86803       };
86804     } catch (...) {
86805       {
86806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86807       };
86808     }
86809   }
86810   jresult = result;
86811   return jresult;
86812 }
86813
86814
86815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(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)->Reference();
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 void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86840   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86841
86842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86843   {
86844     try {
86845       (*arg1)->Unreference();
86846     } catch (std::out_of_range& e) {
86847       {
86848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86849       };
86850     } catch (std::exception& e) {
86851       {
86852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86853       };
86854     } catch (...) {
86855       {
86856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86857       };
86858     }
86859   }
86860 }
86861
86862
86863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86864   int jresult ;
86865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86866   int result;
86867
86868   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86869   {
86870     try {
86871       result = (int)(*arg1)->ReferenceCount();
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (...) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86883       };
86884     }
86885   }
86886   jresult = result;
86887   return jresult;
86888 }
86889
86890
86891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86892   unsigned int jresult ;
86893   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86894   bool result;
86895
86896   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86897   {
86898     try {
86899       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86900     } catch (std::out_of_range& e) {
86901       {
86902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86903       };
86904     } catch (std::exception& e) {
86905       {
86906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86907       };
86908     } catch (...) {
86909       {
86910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86911       };
86912     }
86913   }
86914   jresult = result;
86915   return jresult;
86916 }
86917
86918
86919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86920   unsigned long jresult ;
86921   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86922   std::size_t result;
86923
86924   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86925   {
86926     try {
86927       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86928     } catch (std::out_of_range& e) {
86929       {
86930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86931       };
86932     } catch (std::exception& e) {
86933       {
86934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86935       };
86936     } catch (...) {
86937       {
86938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86939       };
86940     }
86941   }
86942   jresult = (unsigned long)result;
86943   return jresult;
86944 }
86945
86946
86947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86948   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86949   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86950
86951   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86952   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86953   {
86954     try {
86955       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86956     } catch (std::out_of_range& e) {
86957       {
86958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86959       };
86960     } catch (std::exception& e) {
86961       {
86962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86963       };
86964     } catch (...) {
86965       {
86966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86967       };
86968     }
86969   }
86970 }
86971
86972
86973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86974   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86975   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86976
86977   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86978   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86979   {
86980     try {
86981       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86982     } catch (std::out_of_range& e) {
86983       {
86984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86985       };
86986     } catch (std::exception& e) {
86987       {
86988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86989       };
86990     } catch (...) {
86991       {
86992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86993       };
86994     }
86995   }
86996 }
86997
86998
86999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
87000   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87001   Dali::Toolkit::Control arg2 ;
87002   Dali::Toolkit::Control *argp2 ;
87003
87004   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87005   argp2 = (Dali::Toolkit::Control *)jarg2;
87006   if (!argp2) {
87007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87008     return ;
87009   }
87010   arg2 = *argp2;
87011   {
87012     try {
87013       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87014     } catch (std::out_of_range& e) {
87015       {
87016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87017       };
87018     } catch (std::exception& e) {
87019       {
87020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87021       };
87022     } catch (...) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87025       };
87026     }
87027   }
87028 }
87029
87030
87031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87032   void * jresult ;
87033   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87034
87035   {
87036     try {
87037       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87038     } catch (std::out_of_range& e) {
87039       {
87040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87041       };
87042     } catch (std::exception& e) {
87043       {
87044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87045       };
87046     } catch (...) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87049       };
87050     }
87051   }
87052   jresult = (void *)result;
87053   return jresult;
87054 }
87055
87056
87057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87058   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87059
87060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87061   {
87062     try {
87063       delete arg1;
87064     } catch (std::out_of_range& e) {
87065       {
87066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87067       };
87068     } catch (std::exception& e) {
87069       {
87070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87075       };
87076     }
87077   }
87078 }
87079
87080 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87081   Dali::RefObject *result = NULL;
87082
87083   if (arg1)
87084   {
87085     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87086   }
87087   return result;
87088 }
87089
87090 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87091     return (Dali::RefObject *)jarg1;
87092 }
87093
87094 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87095     return (Dali::SignalObserver *)jarg1;
87096 }
87097
87098 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87099     return (Dali::ConnectionTrackerInterface *)jarg1;
87100 }
87101
87102 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87103     return (Dali::BaseHandle *)jarg1;
87104 }
87105
87106 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87107     return (Dali::BaseHandle *)jarg1;
87108 }
87109
87110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87111     return (Dali::BaseHandle *)jarg1;
87112 }
87113
87114 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87115     return (Dali::BaseHandle *)jarg1;
87116 }
87117
87118 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87119     return (Dali::BaseHandle *)jarg1;
87120 }
87121
87122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87123     return (Dali::BaseHandle *)jarg1;
87124 }
87125
87126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87127     return (Dali::BaseHandle *)jarg1;
87128 }
87129
87130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87131     return (Dali::BaseHandle *)jarg1;
87132 }
87133
87134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87135     return (Dali::BaseHandle *)jarg1;
87136 }
87137
87138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87139     return (Dali::BaseHandle *)jarg1;
87140 }
87141
87142 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87143     return (Dali::BaseHandle *)jarg1;
87144 }
87145
87146 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87147     return (Dali::BaseHandle *)jarg1;
87148 }
87149
87150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87151     return (Dali::BaseHandle *)jarg1;
87152 }
87153
87154 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87155     return (Dali::Handle *)jarg1;
87156 }
87157
87158 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87159     return (Dali::Handle *)jarg1;
87160 }
87161
87162 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87163     return (Dali::BaseHandle *)jarg1;
87164 }
87165
87166 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87167     return (Dali::BaseHandle *)jarg1;
87168 }
87169
87170 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87171     return (Dali::Handle *)jarg1;
87172 }
87173
87174 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87175     return (Dali::BaseHandle *)jarg1;
87176 }
87177
87178 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87179     return (Dali::Handle *)jarg1;
87180 }
87181
87182 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87183     return (Dali::GestureDetector *)jarg1;
87184 }
87185
87186 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87187     return (Dali::Gesture *)jarg1;
87188 }
87189
87190 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87191     return (Dali::Handle *)jarg1;
87192 }
87193
87194 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87195     return (Dali::Actor *)jarg1;
87196 }
87197
87198 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87199     return (Dali::BaseHandle *)jarg1;
87200 }
87201
87202 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87203     return (Dali::RefObject *)jarg1;
87204 }
87205
87206 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87207     return (Dali::Actor *)jarg1;
87208 }
87209
87210 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87211     return (Dali::GestureDetector *)jarg1;
87212 }
87213
87214 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87215     return (Dali::Gesture *)jarg1;
87216 }
87217
87218 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87219     return (Dali::GestureDetector *)jarg1;
87220 }
87221
87222 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87223     return (Dali::Gesture *)jarg1;
87224 }
87225
87226 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87227     return (Dali::GestureDetector *)jarg1;
87228 }
87229
87230 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87231     return (Dali::Gesture *)jarg1;
87232 }
87233
87234 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87235     return (Dali::BaseHandle *)jarg1;
87236 }
87237
87238 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87239     return (Dali::Handle *)jarg1;
87240 }
87241
87242 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87243     return (Dali::Handle *)jarg1;
87244 }
87245
87246 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87247     return (Dali::Handle *)jarg1;
87248 }
87249
87250 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87251     return (Dali::Image *)jarg1;
87252 }
87253
87254 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87255     return (Dali::Image *)jarg1;
87256 }
87257
87258 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87259     return (Dali::Image *)jarg1;
87260 }
87261
87262 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87263     return (Dali::RefObject *)jarg1;
87264 }
87265
87266 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87267     return (Dali::Image *)jarg1;
87268 }
87269
87270 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87271     return (Dali::Image *)jarg1;
87272 }
87273
87274 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87275     return (Dali::ResourceImage *)jarg1;
87276 }
87277
87278 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87279     return (Dali::Actor *)jarg1;
87280 }
87281
87282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87283     return (Dali::BaseHandle *)jarg1;
87284 }
87285
87286 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87287     return (Dali::BaseHandle *)jarg1;
87288 }
87289
87290
87291 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87292     return (Dali::BaseHandle *)jarg1;
87293 }
87294
87295 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87296     return (Dali::BaseHandle *)jarg1;
87297 }
87298
87299 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87300     return (Dali::CustomActorImpl *)jarg1;
87301 }
87302
87303 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87304     return (Dali::CustomActor *)jarg1;
87305 }
87306
87307 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87308     return (Dali::BaseHandle *)jarg1;
87309 }
87310
87311 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87312     return (Dali::Toolkit::Control *)jarg1;
87313 }
87314
87315 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87316     return (Dali::Toolkit::Control *)jarg1;
87317 }
87318
87319 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87320     return (Dali::Toolkit::Button *)jarg1;
87321 }
87322
87323 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87324     return (Dali::Toolkit::Button *)jarg1;
87325 }
87326
87327 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87328     return (Dali::Toolkit::Button *)jarg1;
87329 }
87330
87331 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87332     return (Dali::Toolkit::Control *)jarg1;
87333 }
87334
87335 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87336     return (Dali::Toolkit::Control *)jarg1;
87337 }
87338
87339 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87340     return (Dali::Toolkit::Control *)jarg1;
87341 }
87342
87343 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87344     return (Dali::Toolkit::Control *)jarg1;
87345 }
87346
87347 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87348     return (Dali::Toolkit::Control *)jarg1;
87349 }
87350
87351 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87352     return (Dali::RefObject *)jarg1;
87353 }
87354
87355 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87356     return (Dali::Toolkit::Scrollable *)jarg1;
87357 }
87358
87359 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87360     return (Dali::BaseHandle *)jarg1;
87361 }
87362
87363 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87364     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87365 }
87366
87367 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87368     return (Dali::RefObject *)jarg1;
87369 }
87370
87371 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87372     return (Dali::Toolkit::Ruler *)jarg1;
87373 }
87374
87375 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87376     return (Dali::Toolkit::Ruler *)jarg1;
87377 }
87378
87379 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87380     return (Dali::Toolkit::Scrollable *)jarg1;
87381 }
87382
87383 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87384     return (Dali::Toolkit::Control *)jarg1;
87385 }
87386
87387
87388 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87389     return (Dali::Toolkit::Control *)jarg1;
87390 }
87391
87392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87393     return (Dali::BaseHandle *)jarg1;
87394 }
87395
87396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87397     return (Dali::BaseHandle *)jarg1;
87398 }
87399
87400 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87401     return (Dali::Toolkit::Control *)jarg1;
87402 }
87403
87404 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87405     return (Dali::Toolkit::Control *)jarg1;
87406 }
87407
87408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87409     return (Dali::Toolkit::Control *)jarg1;
87410 }
87411
87412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87413     return (Dali::Toolkit::Control *)jarg1;
87414 }
87415
87416 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87417     return (Dali::Toolkit::Control *)jarg1;
87418 }
87419
87420 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87421     return (Dali::Toolkit::Control *)jarg1;
87422 }
87423
87424 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87425     return (Dali::Toolkit::PageTurnView *)jarg1;
87426 }
87427
87428 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87429     return (Dali::Toolkit::PageTurnView *)jarg1;
87430 }
87431
87432 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87433     return (Dali::Toolkit::Button *)jarg1;
87434 }
87435
87436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87437     return (Dali::BaseHandle *)jarg1;
87438 }
87439
87440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87441     return (Dali::BaseHandle *)jarg1;
87442 }
87443
87444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87445     return (Dali::BaseHandle *)jarg1;
87446 }
87447
87448
87449 #ifdef __cplusplus
87450 }
87451 #endif