dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 457 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471
 472
 473 // add here SWIG version check
 474
 475 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 476 // disable Swig-dependent warnings
 477
 478 // 'identifier1' has C-linkage specified,
 479 // but returns UDT 'identifier2' which is incompatible with C
 480 #pragma warning(disable: 4190)
 481
 482 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 483 #pragma warning(disable: 4800)
 484
 485 // debug info too long etc etc
 486 #pragma warning(disable: 4786)
 487 #endif
 488
 489
 490 #include <stdexcept>
 491
 492
 493 #include <string>
 494
 495
 496 #include <vector>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <map>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <utility>
 507
 508
 509 typedef float floatp;
 510
 511 SWIGINTERN floatp *new_floatp(){
 512   return new float();
 513 }
 514 SWIGINTERN void delete_floatp(floatp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void floatp_assign(floatp *self,float value){
 518   *self = value;
 519 }
 520 SWIGINTERN float floatp_value(floatp *self){
 521   return *self;
 522 }
 523 SWIGINTERN float *floatp_cast(floatp *self){
 524   return self;
 525 }
 526 SWIGINTERN floatp *floatp_frompointer(float *t){
 527   return (floatp *) t;
 528 }
 529
 530 typedef int intp;
 531
 532 SWIGINTERN intp *new_intp(){
 533   return new int();
 534 }
 535 SWIGINTERN void delete_intp(intp *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void intp_assign(intp *self,int value){
 539   *self = value;
 540 }
 541 SWIGINTERN int intp_value(intp *self){
 542   return *self;
 543 }
 544 SWIGINTERN int *intp_cast(intp *self){
 545   return self;
 546 }
 547 SWIGINTERN intp *intp_frompointer(int *t){
 548   return (intp *) t;
 549 }
 550
 551 typedef double doublep;
 552
 553 SWIGINTERN doublep *new_doublep(){
 554   return new double();
 555 }
 556 SWIGINTERN void delete_doublep(doublep *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void doublep_assign(doublep *self,double value){
 560   *self = value;
 561 }
 562 SWIGINTERN double doublep_value(doublep *self){
 563   return *self;
 564 }
 565 SWIGINTERN double *doublep_cast(doublep *self){
 566   return self;
 567 }
 568 SWIGINTERN doublep *doublep_frompointer(double *t){
 569   return (doublep *) t;
 570 }
 571
 572 typedef unsigned int uintp;
 573
 574 SWIGINTERN uintp *new_uintp(){
 575   return new unsigned int();
 576 }
 577 SWIGINTERN void delete_uintp(uintp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned int uintp_value(uintp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 587   return self;
 588 }
 589 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 590   return (uintp *) t;
 591 }
 592
 593 typedef unsigned short ushortp;
 594
 595 SWIGINTERN ushortp *new_ushortp(){
 596   return new unsigned short();
 597 }
 598 SWIGINTERN void delete_ushortp(ushortp *self){
 599   if (self) delete self;
 600 }
 601 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 602   *self = value;
 603 }
 604 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 605   return *self;
 606 }
 607 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 608   return self;
 609 }
 610 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 611   return (ushortp *) t;
 612 }
 613
 614 unsigned int int_to_uint(int x) {
 615    return (unsigned int) x;
 616 }
 617
 618
 619 using namespace Dali;
 620 using namespace Dali::Toolkit;
 621
 622 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 623
 624      // C++ code. DALi uses Handle <-> Body design pattern.
 625      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 626      // Handles in DALi can be converted into a boolean type
 627      // to check if the handle has a valid body attached to it.
 628      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 629      if( *self )
 630      {
 631        return true;
 632      }
 633      else
 634      {
 635        return false;
 636      }
 637     }
 638 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 639
 640      // C++ code. Check if two handles reference the same implemtion
 641      if( *self == rhs)
 642      {
 643        return true;
 644      }
 645      else
 646      {
 647        return false;
 648      }
 649     }
 650 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 651      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 652    }
 653 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 654      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 655    }
 656 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 657         std::vector< Dali::TouchPoint >* pv = 0;
 658         if (capacity >= 0) {
 659           pv = new std::vector< Dali::TouchPoint >();
 660           pv->reserve(capacity);
 661        } else {
 662           throw std::out_of_range("capacity");
 663        }
 664        return pv;
 665       }
 666 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 667         if (index>=0 && index<(int)self->size())
 668           return (*self)[index];
 669         else
 670           throw std::out_of_range("index");
 671       }
 672 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 673         if (index>=0 && index<(int)self->size())
 674           return (*self)[index];
 675         else
 676           throw std::out_of_range("index");
 677       }
 678 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 679         if (index>=0 && index<(int)self->size())
 680           (*self)[index] = val;
 681         else
 682           throw std::out_of_range("index");
 683       }
 684 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 685         self->insert(self->end(), values.begin(), values.end());
 686       }
 687 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 688         if (index < 0)
 689           throw std::out_of_range("index");
 690         if (count < 0)
 691           throw std::out_of_range("count");
 692         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 693           throw std::invalid_argument("invalid range");
 694         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 695       }
 696 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 697         if (index>=0 && index<(int)self->size()+1)
 698           self->insert(self->begin()+index, x);
 699         else
 700           throw std::out_of_range("index");
 701       }
 702 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 703         if (index>=0 && index<(int)self->size()+1)
 704           self->insert(self->begin()+index, values.begin(), values.end());
 705         else
 706           throw std::out_of_range("index");
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 709         if (index>=0 && index<(int)self->size())
 710           self->erase(self->begin() + index);
 711         else
 712           throw std::out_of_range("index");
 713       }
 714 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 715         if (index < 0)
 716           throw std::out_of_range("index");
 717         if (count < 0)
 718           throw std::out_of_range("count");
 719         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 720           throw std::invalid_argument("invalid range");
 721         self->erase(self->begin()+index, self->begin()+index+count);
 722       }
 723 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 724         if (count < 0)
 725           throw std::out_of_range("count");
 726         return new std::vector< Dali::TouchPoint >(count, value);
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 729         std::reverse(self->begin(), self->end());
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (count < 0)
 735           throw std::out_of_range("count");
 736         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 737           throw std::invalid_argument("invalid range");
 738         std::reverse(self->begin()+index, self->begin()+index+count);
 739       }
 740 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 741         if (index < 0)
 742           throw std::out_of_range("index");
 743         if (index+values.size() > self->size())
 744           throw std::out_of_range("index");
 745         std::copy(values.begin(), values.end(), self->begin()+index);
 746       }
 747 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 748          return self->Empty();
 749       }
 750 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 751         return self->GetConnectionCount();
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Connect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Disconnect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 760           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 761 /*@SWIG@*/ self->Emit( arg );
 762       }
 763 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764          return self->Empty();
 765       }
 766 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767         return self->GetConnectionCount();
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Connect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Disconnect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 776           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 777 /*@SWIG@*/ self->Emit( arg );
 778       }
 779 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 780          return self->Empty();
 781       }
 782 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 783         return self->GetConnectionCount();
 784       }
 785 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 786           self->Connect( func );
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 789           self->Disconnect( func );
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 792           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 793 /*@SWIG@*/ self->Emit( arg );
 794       }
 795 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796          return self->Empty();
 797       }
 798 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799         return self->GetConnectionCount();
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Connect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Disconnect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 808           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 809 /*@SWIG@*/ self->Emit( arg );
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 834         self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 837         self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 840         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg1, arg2 );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 850         self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 853         self->Disconnect( func );
 854       }
 855 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 856         return self->Emit( arg1, arg2 );
 857       }
 858 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 859          return self->Empty();
 860       }
 861 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 862         return self->GetConnectionCount();
 863       }
 864 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 865         self->Connect( func );
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 868         self->Disconnect( func );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 871         return self->Emit( arg1, arg2 );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 874          return self->Empty();
 875       }
 876 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 877         return self->GetConnectionCount();
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 880         self->Connect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 883         self->Disconnect( func );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 886         return self->Emit( arg1, arg2 );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 901           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 911           self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 914           self->Disconnect( func );
 915       }
 916 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 917           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 918 /*@SWIG@*/ self->Emit( arg );
 919       }
 920 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 921          return self->Empty();
 922       }
 923 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 924         return self->GetConnectionCount();
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 927           self->Connect( func );
 928       }
 929 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 930           self->Disconnect( func );
 931       }
 932 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 933           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 934 /*@SWIG@*/ self->Emit( arg );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 953          return self->Empty();
 954       }
 955 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 956         return self->GetConnectionCount();
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 959         self->Connect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 962         self->Disconnect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 965         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg1, arg2 );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 969          return self->Empty();
 970       }
 971 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 972         return self->GetConnectionCount();
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 975         self->Connect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 978         self->Disconnect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 981         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg1, arg2 );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 985          return self->Empty();
 986       }
 987 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 988         return self->GetConnectionCount();
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 991         self->Connect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 994         self->Disconnect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 997         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg1, arg2 );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1007           self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1010           self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1013           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1017          return self->Empty();
1018       }
1019 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1020         return self->GetConnectionCount();
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1023           return self->Connect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1026           self->Disconnect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1029           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1031       }
1032
1033 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1034          return self->Empty();
1035       }
1036 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1037         return self->GetConnectionCount();
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1040           self->Connect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1043           self->Disconnect( func );
1044       }
1045 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1046           return self->Emit();
1047       }
1048
1049 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1050         std::vector< unsigned int >* pv = 0;
1051         if (capacity >= 0) {
1052           pv = new std::vector< unsigned int >();
1053           pv->reserve(capacity);
1054        } else {
1055           throw std::out_of_range("capacity");
1056        }
1057        return pv;
1058       }
1059 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1060         if (index>=0 && index<(int)self->size())
1061           return (*self)[index];
1062         else
1063           throw std::out_of_range("index");
1064       }
1065 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1066         if (index>=0 && index<(int)self->size())
1067           return (*self)[index];
1068         else
1069           throw std::out_of_range("index");
1070       }
1071 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1072         if (index>=0 && index<(int)self->size())
1073           (*self)[index] = val;
1074         else
1075           throw std::out_of_range("index");
1076       }
1077 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1078         self->insert(self->end(), values.begin(), values.end());
1079       }
1080 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1081         if (index < 0)
1082           throw std::out_of_range("index");
1083         if (count < 0)
1084           throw std::out_of_range("count");
1085         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1086           throw std::invalid_argument("invalid range");
1087         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1088       }
1089 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1090         if (index>=0 && index<(int)self->size()+1)
1091           self->insert(self->begin()+index, x);
1092         else
1093           throw std::out_of_range("index");
1094       }
1095 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1096         if (index>=0 && index<(int)self->size()+1)
1097           self->insert(self->begin()+index, values.begin(), values.end());
1098         else
1099           throw std::out_of_range("index");
1100       }
1101 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1102         if (index>=0 && index<(int)self->size())
1103           self->erase(self->begin() + index);
1104         else
1105           throw std::out_of_range("index");
1106       }
1107 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1108         if (index < 0)
1109           throw std::out_of_range("index");
1110         if (count < 0)
1111           throw std::out_of_range("count");
1112         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1113           throw std::invalid_argument("invalid range");
1114         self->erase(self->begin()+index, self->begin()+index+count);
1115       }
1116 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1117         if (count < 0)
1118           throw std::out_of_range("count");
1119         return new std::vector< unsigned int >(count, value);
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1122         std::reverse(self->begin(), self->end());
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1125         if (index < 0)
1126           throw std::out_of_range("index");
1127         if (count < 0)
1128           throw std::out_of_range("count");
1129         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1130           throw std::invalid_argument("invalid range");
1131         std::reverse(self->begin()+index, self->begin()+index+count);
1132       }
1133 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1134         if (index < 0)
1135           throw std::out_of_range("index");
1136         if (index+values.size() > self->size())
1137           throw std::out_of_range("index");
1138         std::copy(values.begin(), values.end(), self->begin()+index);
1139       }
1140 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1141         return std::find(self->begin(), self->end(), value) != self->end();
1142       }
1143 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1144         int index = -1;
1145         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1146         if (it != self->end())
1147           index = (int)(it - self->begin());
1148         return index;
1149       }
1150 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1151         int index = -1;
1152         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1153         if (rit != self->rend())
1154           index = (int)(self->rend() - 1 - rit);
1155         return index;
1156       }
1157 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1158         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1159         if (it != self->end()) {
1160           self->erase(it);
1161           return true;
1162         }
1163         return false;
1164       }
1165 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1166         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1167         if (capacity >= 0) {
1168           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1169           pv->reserve(capacity);
1170        } else {
1171           throw std::out_of_range("capacity");
1172        }
1173        return pv;
1174       }
1175 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1176         if (index>=0 && index<(int)self->size())
1177           return (*self)[index];
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1182         if (index>=0 && index<(int)self->size())
1183           return (*self)[index];
1184         else
1185           throw std::out_of_range("index");
1186       }
1187 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1188         if (index>=0 && index<(int)self->size())
1189           (*self)[index] = val;
1190         else
1191           throw std::out_of_range("index");
1192       }
1193 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1194         self->insert(self->end(), values.begin(), values.end());
1195       }
1196 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (count < 0)
1200           throw std::out_of_range("count");
1201         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1202           throw std::invalid_argument("invalid range");
1203         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1204       }
1205 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1206         if (index>=0 && index<(int)self->size()+1)
1207           self->insert(self->begin()+index, x);
1208         else
1209           throw std::out_of_range("index");
1210       }
1211 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1212         if (index>=0 && index<(int)self->size()+1)
1213           self->insert(self->begin()+index, values.begin(), values.end());
1214         else
1215           throw std::out_of_range("index");
1216       }
1217 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1218         if (index>=0 && index<(int)self->size())
1219           self->erase(self->begin() + index);
1220         else
1221           throw std::out_of_range("index");
1222       }
1223 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1224         if (index < 0)
1225           throw std::out_of_range("index");
1226         if (count < 0)
1227           throw std::out_of_range("count");
1228         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1229           throw std::invalid_argument("invalid range");
1230         self->erase(self->begin()+index, self->begin()+index+count);
1231       }
1232 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1233         if (count < 0)
1234           throw std::out_of_range("count");
1235         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1236       }
1237 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1238         std::reverse(self->begin(), self->end());
1239       }
1240 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1241         if (index < 0)
1242           throw std::out_of_range("index");
1243         if (count < 0)
1244           throw std::out_of_range("count");
1245         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1246           throw std::invalid_argument("invalid range");
1247         std::reverse(self->begin()+index, self->begin()+index+count);
1248       }
1249 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1250         if (index < 0)
1251           throw std::out_of_range("index");
1252         if (index+values.size() > self->size())
1253           throw std::out_of_range("index");
1254         std::copy(values.begin(), values.end(), self->begin()+index);
1255       }
1256 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1257         std::vector< Dali::Actor >* pv = 0;
1258         if (capacity >= 0) {
1259           pv = new std::vector< Dali::Actor >();
1260           pv->reserve(capacity);
1261        } else {
1262           throw std::out_of_range("capacity");
1263        }
1264        return pv;
1265       }
1266 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1267         if (index>=0 && index<(int)self->size())
1268           return (*self)[index];
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1273         if (index>=0 && index<(int)self->size())
1274           return (*self)[index];
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1279         if (index>=0 && index<(int)self->size())
1280           (*self)[index] = val;
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1285         self->insert(self->end(), values.begin(), values.end());
1286       }
1287 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1297         if (index>=0 && index<(int)self->size()+1)
1298           self->insert(self->begin()+index, x);
1299         else
1300           throw std::out_of_range("index");
1301       }
1302 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1303         if (index>=0 && index<(int)self->size()+1)
1304           self->insert(self->begin()+index, values.begin(), values.end());
1305         else
1306           throw std::out_of_range("index");
1307       }
1308 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1309         if (index>=0 && index<(int)self->size())
1310           self->erase(self->begin() + index);
1311         else
1312           throw std::out_of_range("index");
1313       }
1314 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         self->erase(self->begin()+index, self->begin()+index+count);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1324         if (count < 0)
1325           throw std::out_of_range("count");
1326         return new std::vector< Dali::Actor >(count, value);
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1329         std::reverse(self->begin(), self->end());
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1332         if (index < 0)
1333           throw std::out_of_range("index");
1334         if (count < 0)
1335           throw std::out_of_range("count");
1336         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1337           throw std::invalid_argument("invalid range");
1338         std::reverse(self->begin()+index, self->begin()+index+count);
1339       }
1340 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1341         if (index < 0)
1342           throw std::out_of_range("index");
1343         if (index+values.size() > self->size())
1344           throw std::out_of_range("index");
1345         std::copy(values.begin(), values.end(), self->begin()+index);
1346       }
1347 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1348          return self->Empty();
1349       }
1350 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1351         return self->GetConnectionCount();
1352       }
1353 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1354           self->Connect( func );
1355       }
1356 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1357           self->Disconnect( func );
1358       }
1359 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1360           return self->Emit( arg );
1361       }
1362 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1363          return self->Empty();
1364       }
1365 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1366         return self->GetConnectionCount();
1367       }
1368 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1369         self->Connect( func );
1370       }
1371 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1372         self->Disconnect( func );
1373       }
1374 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1375         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1376 /*@SWIG@*/ self->Emit( arg1, arg2 );
1377       }
1378 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1379          return self->Empty();
1380       }
1381 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1382         return self->GetConnectionCount();
1383       }
1384 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1385         self->Connect( func );
1386       }
1387 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1388         self->Disconnect( func );
1389       }
1390 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1391         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1392 /*@SWIG@*/ self->Emit( arg1, arg2 );
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1401         self->Connect( func );
1402       }
1403 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1404         self->Disconnect( func );
1405       }
1406 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1407         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1408 /*@SWIG@*/ self->Emit( arg1, arg2 );
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1411          return self->Empty();
1412       }
1413 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1414         return self->GetConnectionCount();
1415       }
1416 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1417         self->Connect( func );
1418       }
1419 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1420         self->Disconnect( func );
1421       }
1422 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1423         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1424 /*@SWIG@*/ self->Emit( arg1, arg2 );
1425       }
1426 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1427          return self->Empty();
1428       }
1429 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1430         return self->GetConnectionCount();
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1433           self->Connect( func );
1434       }
1435 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1436           self->Disconnect( func );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1439           return self->Emit( arg );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1448           self->Connect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1451           self->Disconnect( func );
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1454           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1464           return self->Connect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1467           self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1470           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1480           self->Connect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1486           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg );
1488       }
1489 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1490          return self->Empty();
1491       }
1492 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1493         return self->GetConnectionCount();
1494       }
1495 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1496           return self->Connect( func );
1497       }
1498 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1499           self->Disconnect( func );
1500       }
1501 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1502           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1506          return self->Empty();
1507       }
1508 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1509         return self->GetConnectionCount();
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1512           self->Connect( func );
1513       }
1514 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1515           self->Disconnect( func );
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1518           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1519 /*@SWIG@*/ self->Emit( arg );
1520       }
1521 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1522          return self->Empty();
1523       }
1524 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1525         return self->GetConnectionCount();
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1528           self->Connect( func );
1529       }
1530 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1531           self->Disconnect( func );
1532       }
1533 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1534           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1535 /*@SWIG@*/ self->Emit( arg );
1536       }
1537
1538
1539 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1540          return self->Empty();
1541       }
1542 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1543         return self->GetConnectionCount();
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1546         self->Connect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1549         self->Disconnect( func );
1550       }
1551 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1552         return self->Emit( arg1, arg2 );
1553       }
1554 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1555          return self->Empty();
1556       }
1557 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1558         return self->GetConnectionCount();
1559       }
1560 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1561           self->Connect( func );
1562       }
1563 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1564           self->Disconnect( func );
1565       }
1566 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1567           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1568 /*@SWIG@*/ self->Emit( arg );
1569       }
1570 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1571          return self->Empty();
1572       }
1573 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1574         return self->GetConnectionCount();
1575       }
1576 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1577           self->Connect( func );
1578       }
1579 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1580           self->Disconnect( func );
1581       }
1582 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1583           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1584 /*@SWIG@*/ self->Emit( arg );
1585       }
1586 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1587          return self->Empty();
1588       }
1589 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1590         return self->GetConnectionCount();
1591       }
1592 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1593         self->Connect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1596         self->Disconnect( func );
1597       }
1598 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1599         return self->Emit( arg1, arg2 );
1600       }
1601 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1602          return self->Empty();
1603       }
1604 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1605         return self->GetConnectionCount();
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1608         self->Connect( func );
1609       }
1610 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1611         self->Disconnect( func );
1612       }
1613 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1614         return self->Emit( arg1, arg2 );
1615       }
1616
1617
1618 /* ---------------------------------------------------
1619  * C++ director class methods
1620  * --------------------------------------------------- */
1621
1622 #include "dali_wrap.h"
1623
1624 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1625   swig_init_callbacks();
1626 }
1627
1628 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1629
1630 }
1631
1632
1633 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1634   int jdepth  ;
1635
1636   if (!swig_callbackOnStageConnection) {
1637     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1638     return;
1639   } else {
1640     jdepth = depth;
1641     swig_callbackOnStageConnection(jdepth);
1642   }
1643 }
1644
1645 void SwigDirector_ViewImpl::OnStageDisconnection() {
1646   if (!swig_callbackOnStageDisconnection) {
1647     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1648     return;
1649   } else {
1650     swig_callbackOnStageDisconnection();
1651   }
1652 }
1653
1654 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1655   void * jchild = 0 ;
1656
1657   if (!swig_callbackOnChildAdd) {
1658     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1659     return;
1660   } else {
1661     jchild = (Dali::Actor *) &child;
1662     swig_callbackOnChildAdd(jchild);
1663   }
1664 }
1665
1666 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1667   void * jchild = 0 ;
1668
1669   if (!swig_callbackOnChildRemove) {
1670     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1671     return;
1672   } else {
1673     jchild = (Dali::Actor *) &child;
1674     swig_callbackOnChildRemove(jchild);
1675   }
1676 }
1677
1678 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1679   int jindex  ;
1680   void * jpropertyValue  ;
1681
1682   if (!swig_callbackOnPropertySet) {
1683     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1684     return;
1685   } else {
1686     jindex = index;
1687     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1688     swig_callbackOnPropertySet(jindex, jpropertyValue);
1689   }
1690 }
1691
1692 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1693   void * jtargetSize = 0 ;
1694
1695   if (!swig_callbackOnSizeSet) {
1696     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1697     return;
1698   } else {
1699     jtargetSize = (Dali::Vector3 *) &targetSize;
1700     swig_callbackOnSizeSet(jtargetSize);
1701   }
1702 }
1703
1704 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1705   void * janimation = 0 ;
1706   void * jtargetSize = 0 ;
1707
1708   if (!swig_callbackOnSizeAnimation) {
1709     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1710     return;
1711   } else {
1712     janimation = (Dali::Animation *) &animation;
1713     jtargetSize = (Dali::Vector3 *) &targetSize;
1714     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1715   }
1716 }
1717
1718 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1719   bool c_result = SwigValueInit< bool >() ;
1720   unsigned int jresult = 0 ;
1721   void * jarg0 = 0 ;
1722
1723   if (!swig_callbackOnTouchEvent) {
1724     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1725   } else {
1726     jarg0 = (Dali::TouchEvent *) &event;
1727     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1728     c_result = jresult ? true : false;
1729   }
1730   return c_result;
1731 }
1732
1733 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1734   bool c_result = SwigValueInit< bool >() ;
1735   unsigned int jresult = 0 ;
1736   void * jarg0 = 0 ;
1737
1738   if (!swig_callbackOnHoverEvent) {
1739     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1740   } else {
1741     jarg0 = (Dali::HoverEvent *) &event;
1742     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1743     c_result = jresult ? true : false;
1744   }
1745   return c_result;
1746 }
1747
1748 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1749   bool c_result = SwigValueInit< bool >() ;
1750   unsigned int jresult = 0 ;
1751   void * jarg0 = 0 ;
1752
1753   if (!swig_callbackOnKeyEvent) {
1754     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1755   } else {
1756     jarg0 = (Dali::KeyEvent *) &event;
1757     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1758     c_result = jresult ? true : false;
1759   }
1760   return c_result;
1761 }
1762
1763 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1764   bool c_result = SwigValueInit< bool >() ;
1765   unsigned int jresult = 0 ;
1766   void * jarg0 = 0 ;
1767
1768   if (!swig_callbackOnWheelEvent) {
1769     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1770   } else {
1771     jarg0 = (Dali::WheelEvent *) &event;
1772     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1773     c_result = jresult ? true : false;
1774   }
1775   return c_result;
1776 }
1777
1778 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1779   void * jsize = 0 ;
1780   void * jcontainer = 0 ;
1781
1782   if (!swig_callbackOnRelayout) {
1783     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1784     return;
1785   } else {
1786     jsize = (Dali::Vector2 *) &size;
1787     jcontainer = (Dali::RelayoutContainer *) &container;
1788     swig_callbackOnRelayout(jsize, jcontainer);
1789   }
1790 }
1791
1792 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1793   int jpolicy  ;
1794   int jdimension  ;
1795
1796   if (!swig_callbackOnSetResizePolicy) {
1797     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1798     return;
1799   } else {
1800     jpolicy = (int)policy;
1801     jdimension = (int)dimension;
1802     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1803   }
1804 }
1805
1806 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1807   Dali::Vector3 c_result ;
1808   void * jresult = 0 ;
1809
1810   if (!swig_callbackGetNaturalSize) {
1811     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1812   } else {
1813     jresult = (void *) swig_callbackGetNaturalSize();
1814     if (!jresult) {
1815       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1816       return c_result;
1817     }
1818     c_result = *(Dali::Vector3 *)jresult;
1819   }
1820   return c_result;
1821 }
1822
1823 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1824   float c_result = SwigValueInit< float >() ;
1825   float jresult = 0 ;
1826   void * jchild = 0 ;
1827   int jdimension  ;
1828
1829   if (!swig_callbackCalculateChildSize) {
1830     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1831   } else {
1832     jchild = (Dali::Actor *) &child;
1833     jdimension = (int)dimension;
1834     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1835     c_result = (float)jresult;
1836   }
1837   return c_result;
1838 }
1839
1840 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1841   float c_result = SwigValueInit< float >() ;
1842   float jresult = 0 ;
1843   float jwidth  ;
1844
1845   if (!swig_callbackGetHeightForWidth) {
1846     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1847   } else {
1848     jwidth = width;
1849     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1850     c_result = (float)jresult;
1851   }
1852   return c_result;
1853 }
1854
1855 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1856   float c_result = SwigValueInit< float >() ;
1857   float jresult = 0 ;
1858   float jheight  ;
1859
1860   if (!swig_callbackGetWidthForHeight) {
1861     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1862   } else {
1863     jheight = height;
1864     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1865     c_result = (float)jresult;
1866   }
1867   return c_result;
1868 }
1869
1870 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1871   bool c_result = SwigValueInit< bool >() ;
1872   unsigned int jresult = 0 ;
1873   int jdimension  ;
1874
1875   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1876     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1877   } else {
1878     jdimension = (int)dimension;
1879     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1880     c_result = jresult ? true : false;
1881   }
1882   return c_result;
1883 }
1884
1885 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1886   int jdimension  ;
1887
1888   if (!swig_callbackOnCalculateRelayoutSize) {
1889     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1890     return;
1891   } else {
1892     jdimension = (int)dimension;
1893     swig_callbackOnCalculateRelayoutSize(jdimension);
1894   }
1895 }
1896
1897 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1898   float jsize  ;
1899   int jdimension  ;
1900
1901   if (!swig_callbackOnLayoutNegotiated) {
1902     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1903     return;
1904   } else {
1905     jsize = size;
1906     jdimension = (int)dimension;
1907     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1908   }
1909 }
1910
1911 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1912   return Dali::CustomActorImpl::GetExtension();
1913 }
1914
1915 void SwigDirector_ViewImpl::OnInitialize() {
1916   if (!swig_callbackOnInitialize) {
1917     Dali::Toolkit::Internal::Control::OnInitialize();
1918     return;
1919   } else {
1920     swig_callbackOnInitialize();
1921   }
1922 }
1923
1924 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1925   void * jchild = 0 ;
1926
1927   if (!swig_callbackOnControlChildAdd) {
1928     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1929     return;
1930   } else {
1931     jchild = (Dali::Actor *) &child;
1932     swig_callbackOnControlChildAdd(jchild);
1933   }
1934 }
1935
1936 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1937   void * jchild = 0 ;
1938
1939   if (!swig_callbackOnControlChildRemove) {
1940     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1941     return;
1942   } else {
1943     jchild = (Dali::Actor *) &child;
1944     swig_callbackOnControlChildRemove(jchild);
1945   }
1946 }
1947
1948 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1949   void * jstyleManager  ;
1950   int jchange  ;
1951
1952   if (!swig_callbackOnStyleChange) {
1953     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1954     return;
1955   } else {
1956     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1957     jchange = (int)change;
1958     swig_callbackOnStyleChange(jstyleManager, jchange);
1959   }
1960 }
1961
1962 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1963   bool c_result = SwigValueInit< bool >() ;
1964   unsigned int jresult = 0 ;
1965
1966   if (!swig_callbackOnAccessibilityActivated) {
1967     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1968   } else {
1969     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1970     c_result = jresult ? true : false;
1971   }
1972   return c_result;
1973 }
1974
1975 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1976   bool c_result = SwigValueInit< bool >() ;
1977   unsigned int jresult = 0 ;
1978   void * jgesture  ;
1979
1980   if (!swig_callbackOnAccessibilityPan) {
1981     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1982   } else {
1983     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1984     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1985     c_result = jresult ? true : false;
1986   }
1987   return c_result;
1988 }
1989
1990 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1991   bool c_result = SwigValueInit< bool >() ;
1992   unsigned int jresult = 0 ;
1993   void * jtouchEvent = 0 ;
1994
1995   if (!swig_callbackOnAccessibilityTouch) {
1996     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1997   } else {
1998     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1999     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2000     c_result = jresult ? true : false;
2001   }
2002   return c_result;
2003 }
2004
2005 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2006   bool c_result = SwigValueInit< bool >() ;
2007   unsigned int jresult = 0 ;
2008   unsigned int jisIncrease  ;
2009
2010   if (!swig_callbackOnAccessibilityValueChange) {
2011     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2012   } else {
2013     jisIncrease = isIncrease;
2014     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2015     c_result = jresult ? true : false;
2016   }
2017   return c_result;
2018 }
2019
2020 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2021   bool c_result = SwigValueInit< bool >() ;
2022   unsigned int jresult = 0 ;
2023
2024   if (!swig_callbackOnAccessibilityZoom) {
2025     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2026   } else {
2027     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2028     c_result = jresult ? true : false;
2029   }
2030   return c_result;
2031 }
2032
2033 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2034   if (!swig_callbackOnKeyInputFocusGained) {
2035     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2036     return;
2037   } else {
2038     swig_callbackOnKeyInputFocusGained();
2039   }
2040 }
2041
2042 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2043   if (!swig_callbackOnKeyInputFocusLost) {
2044     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2045     return;
2046   } else {
2047     swig_callbackOnKeyInputFocusLost();
2048   }
2049 }
2050
2051 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2052   Dali::Actor c_result ;
2053   void * jresult = 0 ;
2054   void * jcurrentFocusedActor  ;
2055   int jdirection  ;
2056   unsigned int jloopEnabled  ;
2057
2058   if (!swig_callbackGetNextKeyboardFocusableActor) {
2059     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2060   } else {
2061     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2062     jdirection = (int)direction;
2063     jloopEnabled = loopEnabled;
2064     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2065     if (!jresult) {
2066       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2067       return c_result;
2068     }
2069     c_result = *(Dali::Actor *)jresult;
2070   }
2071   return c_result;
2072 }
2073
2074 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2075   void * jcommitedFocusableActor  ;
2076
2077   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2078     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2079     return;
2080   } else {
2081     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2082     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2083   }
2084 }
2085
2086 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2087   bool c_result = SwigValueInit< bool >() ;
2088   unsigned int jresult = 0 ;
2089
2090   if (!swig_callbackOnKeyboardEnter) {
2091     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2092   } else {
2093     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2094     c_result = jresult ? true : false;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2100   void * jpinch = 0 ;
2101
2102   if (!swig_callbackOnPinch) {
2103     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2104     return;
2105   } else {
2106     jpinch = (Dali::PinchGesture *) &pinch;
2107     swig_callbackOnPinch(jpinch);
2108   }
2109 }
2110
2111 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2112   void * jpan = 0 ;
2113
2114   if (!swig_callbackOnPan) {
2115     Dali::Toolkit::Internal::Control::OnPan(pan);
2116     return;
2117   } else {
2118     jpan = (Dali::PanGesture *) &pan;
2119     swig_callbackOnPan(jpan);
2120   }
2121 }
2122
2123 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2124   void * jtap = 0 ;
2125
2126   if (!swig_callbackOnTap) {
2127     Dali::Toolkit::Internal::Control::OnTap(tap);
2128     return;
2129   } else {
2130     jtap = (Dali::TapGesture *) &tap;
2131     swig_callbackOnTap(jtap);
2132   }
2133 }
2134
2135 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2136   void * jlongPress = 0 ;
2137
2138   if (!swig_callbackOnLongPress) {
2139     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2140     return;
2141   } else {
2142     jlongPress = (Dali::LongPressGesture *) &longPress;
2143     swig_callbackOnLongPress(jlongPress);
2144   }
2145 }
2146
2147 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2148   void * jslotObserver = 0 ;
2149   void * jcallback = 0 ;
2150
2151   if (!swig_callbackSignalConnected) {
2152     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2153     return;
2154   } else {
2155     jslotObserver = (void *) slotObserver;
2156     jcallback = (void *) callback;
2157     swig_callbackSignalConnected(jslotObserver, jcallback);
2158   }
2159 }
2160
2161 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2162   void * jslotObserver = 0 ;
2163   void * jcallback = 0 ;
2164
2165   if (!swig_callbackSignalDisconnected) {
2166     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2167     return;
2168   } else {
2169     jslotObserver = (void *) slotObserver;
2170     jcallback = (void *) callback;
2171     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2172   }
2173 }
2174
2175 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2176   return Dali::Toolkit::Internal::Control::GetControlExtension();
2177 }
2178
2179 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2180   swig_callbackOnStageConnection = callbackOnStageConnection;
2181   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2182   swig_callbackOnChildAdd = callbackOnChildAdd;
2183   swig_callbackOnChildRemove = callbackOnChildRemove;
2184   swig_callbackOnPropertySet = callbackOnPropertySet;
2185   swig_callbackOnSizeSet = callbackOnSizeSet;
2186   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2187   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2188   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2189   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2190   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2191   swig_callbackOnRelayout = callbackOnRelayout;
2192   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2193   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2194   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2195   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2196   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2197   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2198   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2199   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2200   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2201   swig_callbackOnInitialize = callbackOnInitialize;
2202   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2203   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2204   swig_callbackOnStyleChange = callbackOnStyleChange;
2205   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2206   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2207   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2208   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2209   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2210   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2211   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2212   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2213   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2214   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2215   swig_callbackOnPinch = callbackOnPinch;
2216   swig_callbackOnPan = callbackOnPan;
2217   swig_callbackOnTap = callbackOnTap;
2218   swig_callbackOnLongPress = callbackOnLongPress;
2219   swig_callbackSignalConnected = callbackSignalConnected;
2220   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2221 }
2222
2223 void SwigDirector_ViewImpl::swig_init_callbacks() {
2224   swig_callbackOnStageConnection = 0;
2225   swig_callbackOnStageDisconnection = 0;
2226   swig_callbackOnChildAdd = 0;
2227   swig_callbackOnChildRemove = 0;
2228   swig_callbackOnPropertySet = 0;
2229   swig_callbackOnSizeSet = 0;
2230   swig_callbackOnSizeAnimation = 0;
2231   swig_callbackOnTouchEvent = 0;
2232   swig_callbackOnHoverEvent = 0;
2233   swig_callbackOnKeyEvent = 0;
2234   swig_callbackOnWheelEvent = 0;
2235   swig_callbackOnRelayout = 0;
2236   swig_callbackOnSetResizePolicy = 0;
2237   swig_callbackGetNaturalSize = 0;
2238   swig_callbackCalculateChildSize = 0;
2239   swig_callbackGetHeightForWidth = 0;
2240   swig_callbackGetWidthForHeight = 0;
2241   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2242   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2243   swig_callbackOnCalculateRelayoutSize = 0;
2244   swig_callbackOnLayoutNegotiated = 0;
2245   swig_callbackOnInitialize = 0;
2246   swig_callbackOnControlChildAdd = 0;
2247   swig_callbackOnControlChildRemove = 0;
2248   swig_callbackOnStyleChange = 0;
2249   swig_callbackOnAccessibilityActivated = 0;
2250   swig_callbackOnAccessibilityPan = 0;
2251   swig_callbackOnAccessibilityTouch = 0;
2252   swig_callbackOnAccessibilityValueChange = 0;
2253   swig_callbackOnAccessibilityZoom = 0;
2254   swig_callbackOnKeyInputFocusGained = 0;
2255   swig_callbackOnKeyInputFocusLost = 0;
2256   swig_callbackGetNextKeyboardFocusableActor = 0;
2257   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2258   swig_callbackOnKeyboardEnter = 0;
2259   swig_callbackOnPinch = 0;
2260   swig_callbackOnPan = 0;
2261   swig_callbackOnTap = 0;
2262   swig_callbackOnLongPress = 0;
2263   swig_callbackSignalConnected = 0;
2264   swig_callbackSignalDisconnected = 0;
2265 }
2266
2267 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2268   swig_init_callbacks();
2269 }
2270
2271 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2272
2273 }
2274
2275
2276 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2277   unsigned int c_result = SwigValueInit< unsigned int >() ;
2278   unsigned int jresult = 0 ;
2279
2280   if (!swig_callbackGetNumberOfItems) {
2281     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2282   } else {
2283     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2284     c_result = (unsigned int)jresult;
2285   }
2286   return c_result;
2287 }
2288
2289 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2290   Dali::Actor c_result ;
2291   void * jresult = 0 ;
2292   unsigned int jitemId  ;
2293
2294   if (!swig_callbackNewItem) {
2295     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2296   } else {
2297     jitemId = itemId;
2298     jresult = (void *) swig_callbackNewItem(jitemId);
2299     if (!jresult) {
2300       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2301       return c_result;
2302     }
2303     c_result = *(Dali::Actor *)jresult;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2309   unsigned int jitemId  ;
2310   void * jactor  ;
2311
2312   if (!swig_callbackItemReleased) {
2313     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2314     return;
2315   } else {
2316     jitemId = itemId;
2317     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2318     swig_callbackItemReleased(jitemId, jactor);
2319   }
2320 }
2321
2322 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2323   return Dali::Toolkit::ItemFactory::GetExtension();
2324 }
2325
2326 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2327   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2328   swig_callbackNewItem = callbackNewItem;
2329   swig_callbackItemReleased = callbackItemReleased;
2330 }
2331
2332 void SwigDirector_ItemFactory::swig_init_callbacks() {
2333   swig_callbackGetNumberOfItems = 0;
2334   swig_callbackNewItem = 0;
2335   swig_callbackItemReleased = 0;
2336 }
2337
2338 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2339   swig_init_callbacks();
2340 }
2341
2342 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2343
2344 }
2345
2346
2347 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2348   Dali::Actor c_result ;
2349   void * jresult = 0 ;
2350   void * jcurrent  ;
2351   void * jproposed  ;
2352   int jdirection  ;
2353
2354   if (!swig_callbackGetNextFocusableActor) {
2355     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2356   } else {
2357     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2358     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2359     jdirection = (int)direction;
2360     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2361     if (!jresult) {
2362       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2363       return c_result;
2364     }
2365     c_result = *(Dali::Actor *)jresult;
2366   }
2367   return c_result;
2368 }
2369
2370 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2371   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2372 }
2373
2374 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2375   swig_callbackGetNextFocusableActor = 0;
2376 }
2377
2378
2379 #ifdef __cplusplus
2380 extern "C" {
2381 #endif
2382
2383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2384   void * jresult ;
2385   floatp *result = 0 ;
2386
2387   {
2388     try {
2389       result = (floatp *)new_floatp();
2390     } catch (std::out_of_range& e) {
2391       {
2392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2393       };
2394     } catch (std::exception& e) {
2395       {
2396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2397       };
2398     } catch (...) {
2399       {
2400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2401       };
2402     }
2403   }
2404   jresult = (void *)result;
2405   return jresult;
2406 }
2407
2408
2409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2410   floatp *arg1 = (floatp *) 0 ;
2411
2412   arg1 = (floatp *)jarg1;
2413   {
2414     try {
2415       delete_floatp(arg1);
2416     } catch (std::out_of_range& e) {
2417       {
2418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2419       };
2420     } catch (std::exception& e) {
2421       {
2422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2423       };
2424     } catch (...) {
2425       {
2426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2427       };
2428     }
2429   }
2430 }
2431
2432
2433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2434   floatp *arg1 = (floatp *) 0 ;
2435   float arg2 ;
2436
2437   arg1 = (floatp *)jarg1;
2438   arg2 = (float)jarg2;
2439   {
2440     try {
2441       floatp_assign(arg1,arg2);
2442     } catch (std::out_of_range& e) {
2443       {
2444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2445       };
2446     } catch (std::exception& e) {
2447       {
2448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2449       };
2450     } catch (...) {
2451       {
2452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2453       };
2454     }
2455   }
2456 }
2457
2458
2459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2460   float jresult ;
2461   floatp *arg1 = (floatp *) 0 ;
2462   float result;
2463
2464   arg1 = (floatp *)jarg1;
2465   {
2466     try {
2467       result = (float)floatp_value(arg1);
2468     } catch (std::out_of_range& e) {
2469       {
2470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2471       };
2472     } catch (std::exception& e) {
2473       {
2474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2475       };
2476     } catch (...) {
2477       {
2478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2479       };
2480     }
2481   }
2482   jresult = result;
2483   return jresult;
2484 }
2485
2486
2487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2488   void * jresult ;
2489   floatp *arg1 = (floatp *) 0 ;
2490   float *result = 0 ;
2491
2492   arg1 = (floatp *)jarg1;
2493   {
2494     try {
2495       result = (float *)floatp_cast(arg1);
2496     } catch (std::out_of_range& e) {
2497       {
2498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2499       };
2500     } catch (std::exception& e) {
2501       {
2502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2503       };
2504     } catch (...) {
2505       {
2506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2507       };
2508     }
2509   }
2510   jresult = (void *)result;
2511   return jresult;
2512 }
2513
2514
2515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2516   void * jresult ;
2517   float *arg1 = (float *) 0 ;
2518   floatp *result = 0 ;
2519
2520   arg1 = (float *)jarg1;
2521   {
2522     try {
2523       result = (floatp *)floatp_frompointer(arg1);
2524     } catch (std::out_of_range& e) {
2525       {
2526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2527       };
2528     } catch (std::exception& e) {
2529       {
2530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2531       };
2532     } catch (...) {
2533       {
2534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2535       };
2536     }
2537   }
2538   jresult = (void *)result;
2539   return jresult;
2540 }
2541
2542
2543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2544   void * jresult ;
2545   intp *result = 0 ;
2546
2547   {
2548     try {
2549       result = (intp *)new_intp();
2550     } catch (std::out_of_range& e) {
2551       {
2552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2553       };
2554     } catch (std::exception& e) {
2555       {
2556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2557       };
2558     } catch (...) {
2559       {
2560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2561       };
2562     }
2563   }
2564   jresult = (void *)result;
2565   return jresult;
2566 }
2567
2568
2569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2570   intp *arg1 = (intp *) 0 ;
2571
2572   arg1 = (intp *)jarg1;
2573   {
2574     try {
2575       delete_intp(arg1);
2576     } catch (std::out_of_range& e) {
2577       {
2578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2579       };
2580     } catch (std::exception& e) {
2581       {
2582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2583       };
2584     } catch (...) {
2585       {
2586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2587       };
2588     }
2589   }
2590 }
2591
2592
2593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2594   intp *arg1 = (intp *) 0 ;
2595   int arg2 ;
2596
2597   arg1 = (intp *)jarg1;
2598   arg2 = (int)jarg2;
2599   {
2600     try {
2601       intp_assign(arg1,arg2);
2602     } catch (std::out_of_range& e) {
2603       {
2604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2605       };
2606     } catch (std::exception& e) {
2607       {
2608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2609       };
2610     } catch (...) {
2611       {
2612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2613       };
2614     }
2615   }
2616 }
2617
2618
2619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2620   int jresult ;
2621   intp *arg1 = (intp *) 0 ;
2622   int result;
2623
2624   arg1 = (intp *)jarg1;
2625   {
2626     try {
2627       result = (int)intp_value(arg1);
2628     } catch (std::out_of_range& e) {
2629       {
2630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (std::exception& e) {
2633       {
2634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2635       };
2636     } catch (...) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2639       };
2640     }
2641   }
2642   jresult = result;
2643   return jresult;
2644 }
2645
2646
2647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2648   void * jresult ;
2649   intp *arg1 = (intp *) 0 ;
2650   int *result = 0 ;
2651
2652   arg1 = (intp *)jarg1;
2653   {
2654     try {
2655       result = (int *)intp_cast(arg1);
2656     } catch (std::out_of_range& e) {
2657       {
2658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2659       };
2660     } catch (std::exception& e) {
2661       {
2662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2667       };
2668     }
2669   }
2670   jresult = (void *)result;
2671   return jresult;
2672 }
2673
2674
2675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2676   void * jresult ;
2677   int *arg1 = (int *) 0 ;
2678   intp *result = 0 ;
2679
2680   arg1 = (int *)jarg1;
2681   {
2682     try {
2683       result = (intp *)intp_frompointer(arg1);
2684     } catch (std::out_of_range& e) {
2685       {
2686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2687       };
2688     } catch (std::exception& e) {
2689       {
2690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (...) {
2693       {
2694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2695       };
2696     }
2697   }
2698   jresult = (void *)result;
2699   return jresult;
2700 }
2701
2702
2703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2704   void * jresult ;
2705   doublep *result = 0 ;
2706
2707   {
2708     try {
2709       result = (doublep *)new_doublep();
2710     } catch (std::out_of_range& e) {
2711       {
2712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (std::exception& e) {
2715       {
2716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (...) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2721       };
2722     }
2723   }
2724   jresult = (void *)result;
2725   return jresult;
2726 }
2727
2728
2729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2730   doublep *arg1 = (doublep *) 0 ;
2731
2732   arg1 = (doublep *)jarg1;
2733   {
2734     try {
2735       delete_doublep(arg1);
2736     } catch (std::out_of_range& e) {
2737       {
2738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2739       };
2740     } catch (std::exception& e) {
2741       {
2742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2743       };
2744     } catch (...) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2747       };
2748     }
2749   }
2750 }
2751
2752
2753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2754   doublep *arg1 = (doublep *) 0 ;
2755   double arg2 ;
2756
2757   arg1 = (doublep *)jarg1;
2758   arg2 = (double)jarg2;
2759   {
2760     try {
2761       doublep_assign(arg1,arg2);
2762     } catch (std::out_of_range& e) {
2763       {
2764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2765       };
2766     } catch (std::exception& e) {
2767       {
2768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2769       };
2770     } catch (...) {
2771       {
2772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2773       };
2774     }
2775   }
2776 }
2777
2778
2779 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2780   double jresult ;
2781   doublep *arg1 = (doublep *) 0 ;
2782   double result;
2783
2784   arg1 = (doublep *)jarg1;
2785   {
2786     try {
2787       result = (double)doublep_value(arg1);
2788     } catch (std::out_of_range& e) {
2789       {
2790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (std::exception& e) {
2793       {
2794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802   jresult = result;
2803   return jresult;
2804 }
2805
2806
2807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2808   void * jresult ;
2809   doublep *arg1 = (doublep *) 0 ;
2810   double *result = 0 ;
2811
2812   arg1 = (doublep *)jarg1;
2813   {
2814     try {
2815       result = (double *)doublep_cast(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2827       };
2828     }
2829   }
2830   jresult = (void *)result;
2831   return jresult;
2832 }
2833
2834
2835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2836   void * jresult ;
2837   double *arg1 = (double *) 0 ;
2838   doublep *result = 0 ;
2839
2840   arg1 = (double *)jarg1;
2841   {
2842     try {
2843       result = (doublep *)doublep_frompointer(arg1);
2844     } catch (std::out_of_range& e) {
2845       {
2846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2847       };
2848     } catch (std::exception& e) {
2849       {
2850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2851       };
2852     } catch (...) {
2853       {
2854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2855       };
2856     }
2857   }
2858   jresult = (void *)result;
2859   return jresult;
2860 }
2861
2862
2863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2864   void * jresult ;
2865   uintp *result = 0 ;
2866
2867   {
2868     try {
2869       result = (uintp *)new_uintp();
2870     } catch (std::out_of_range& e) {
2871       {
2872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2873       };
2874     } catch (std::exception& e) {
2875       {
2876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2877       };
2878     } catch (...) {
2879       {
2880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2881       };
2882     }
2883   }
2884   jresult = (void *)result;
2885   return jresult;
2886 }
2887
2888
2889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2890   uintp *arg1 = (uintp *) 0 ;
2891
2892   arg1 = (uintp *)jarg1;
2893   {
2894     try {
2895       delete_uintp(arg1);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2903       };
2904     } catch (...) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2907       };
2908     }
2909   }
2910 }
2911
2912
2913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2914   uintp *arg1 = (uintp *) 0 ;
2915   unsigned int arg2 ;
2916
2917   arg1 = (uintp *)jarg1;
2918   arg2 = (unsigned int)jarg2;
2919   {
2920     try {
2921       uintp_assign(arg1,arg2);
2922     } catch (std::out_of_range& e) {
2923       {
2924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2925       };
2926     } catch (std::exception& e) {
2927       {
2928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2929       };
2930     } catch (...) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2933       };
2934     }
2935   }
2936 }
2937
2938
2939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2940   unsigned int jresult ;
2941   uintp *arg1 = (uintp *) 0 ;
2942   unsigned int result;
2943
2944   arg1 = (uintp *)jarg1;
2945   {
2946     try {
2947       result = (unsigned int)uintp_value(arg1);
2948     } catch (std::out_of_range& e) {
2949       {
2950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (std::exception& e) {
2953       {
2954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962   jresult = result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2968   void * jresult ;
2969   uintp *arg1 = (uintp *) 0 ;
2970   unsigned int *result = 0 ;
2971
2972   arg1 = (uintp *)jarg1;
2973   {
2974     try {
2975       result = (unsigned int *)uintp_cast(arg1);
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2987       };
2988     }
2989   }
2990   jresult = (void *)result;
2991   return jresult;
2992 }
2993
2994
2995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2996   void * jresult ;
2997   unsigned int *arg1 = (unsigned int *) 0 ;
2998   uintp *result = 0 ;
2999
3000   arg1 = (unsigned int *)jarg1;
3001   {
3002     try {
3003       result = (uintp *)uintp_frompointer(arg1);
3004     } catch (std::out_of_range& e) {
3005       {
3006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3007       };
3008     } catch (std::exception& e) {
3009       {
3010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3011       };
3012     } catch (...) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3015       };
3016     }
3017   }
3018   jresult = (void *)result;
3019   return jresult;
3020 }
3021
3022
3023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3024   void * jresult ;
3025   ushortp *result = 0 ;
3026
3027   {
3028     try {
3029       result = (ushortp *)new_ushortp();
3030     } catch (std::out_of_range& e) {
3031       {
3032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3033       };
3034     } catch (std::exception& e) {
3035       {
3036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3041       };
3042     }
3043   }
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3050   ushortp *arg1 = (ushortp *) 0 ;
3051
3052   arg1 = (ushortp *)jarg1;
3053   {
3054     try {
3055       delete_ushortp(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3063       };
3064     } catch (...) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3067       };
3068     }
3069   }
3070 }
3071
3072
3073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3074   ushortp *arg1 = (ushortp *) 0 ;
3075   unsigned short arg2 ;
3076
3077   arg1 = (ushortp *)jarg1;
3078   arg2 = (unsigned short)jarg2;
3079   {
3080     try {
3081       ushortp_assign(arg1,arg2);
3082     } catch (std::out_of_range& e) {
3083       {
3084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3085       };
3086     } catch (std::exception& e) {
3087       {
3088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3089       };
3090     } catch (...) {
3091       {
3092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3093       };
3094     }
3095   }
3096 }
3097
3098
3099 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3100   unsigned short jresult ;
3101   ushortp *arg1 = (ushortp *) 0 ;
3102   unsigned short result;
3103
3104   arg1 = (ushortp *)jarg1;
3105   {
3106     try {
3107       result = (unsigned short)ushortp_value(arg1);
3108     } catch (std::out_of_range& e) {
3109       {
3110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (std::exception& e) {
3113       {
3114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3115       };
3116     } catch (...) {
3117       {
3118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3119       };
3120     }
3121   }
3122   jresult = result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3128   void * jresult ;
3129   ushortp *arg1 = (ushortp *) 0 ;
3130   unsigned short *result = 0 ;
3131
3132   arg1 = (ushortp *)jarg1;
3133   {
3134     try {
3135       result = (unsigned short *)ushortp_cast(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3147       };
3148     }
3149   }
3150   jresult = (void *)result;
3151   return jresult;
3152 }
3153
3154
3155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3156   void * jresult ;
3157   unsigned short *arg1 = (unsigned short *) 0 ;
3158   ushortp *result = 0 ;
3159
3160   arg1 = (unsigned short *)jarg1;
3161   {
3162     try {
3163       result = (ushortp *)ushortp_frompointer(arg1);
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (...) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3175       };
3176     }
3177   }
3178   jresult = (void *)result;
3179   return jresult;
3180 }
3181
3182
3183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3184   unsigned int jresult ;
3185   int arg1 ;
3186   unsigned int result;
3187
3188   arg1 = (int)jarg1;
3189   {
3190     try {
3191       result = (unsigned int)int_to_uint(arg1);
3192     } catch (std::out_of_range& e) {
3193       {
3194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3195       };
3196     } catch (std::exception& e) {
3197       {
3198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3199       };
3200     } catch (...) {
3201       {
3202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3203       };
3204     }
3205   }
3206   jresult = result;
3207   return jresult;
3208 }
3209
3210
3211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3212   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3213
3214   arg1 = (Dali::RefObject *)jarg1;
3215   {
3216     try {
3217       (arg1)->Reference();
3218     } catch (std::out_of_range& e) {
3219       {
3220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3221       };
3222     } catch (std::exception& e) {
3223       {
3224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3225       };
3226     } catch (...) {
3227       {
3228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3229       };
3230     }
3231   }
3232 }
3233
3234
3235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3236   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3237
3238   arg1 = (Dali::RefObject *)jarg1;
3239   {
3240     try {
3241       (arg1)->Unreference();
3242     } catch (std::out_of_range& e) {
3243       {
3244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3245       };
3246     } catch (std::exception& e) {
3247       {
3248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3249       };
3250     } catch (...) {
3251       {
3252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3253       };
3254     }
3255   }
3256 }
3257
3258
3259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3260   int jresult ;
3261   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3262   int result;
3263
3264   arg1 = (Dali::RefObject *)jarg1;
3265   {
3266     try {
3267       result = (int)(arg1)->ReferenceCount();
3268     } catch (std::out_of_range& e) {
3269       {
3270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (std::exception& e) {
3273       {
3274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3275       };
3276     } catch (...) {
3277       {
3278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3279       };
3280     }
3281   }
3282   jresult = result;
3283   return jresult;
3284 }
3285
3286
3287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3288   void * jresult ;
3289   Dali::Any *result = 0 ;
3290
3291   {
3292     try {
3293       result = (Dali::Any *)new Dali::Any();
3294     } catch (std::out_of_range& e) {
3295       {
3296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (std::exception& e) {
3299       {
3300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308   jresult = (void *)result;
3309   return jresult;
3310 }
3311
3312
3313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3314   Dali::Any *arg1 = (Dali::Any *) 0 ;
3315
3316   arg1 = (Dali::Any *)jarg1;
3317   {
3318     try {
3319       delete arg1;
3320     } catch (std::out_of_range& e) {
3321       {
3322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3323       };
3324     } catch (std::exception& e) {
3325       {
3326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3327       };
3328     } catch (...) {
3329       {
3330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3331       };
3332     }
3333   }
3334 }
3335
3336
3337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3338   char *arg1 = (char *) 0 ;
3339
3340   arg1 = (char *)jarg1;
3341   {
3342     try {
3343       Dali::Any::AssertAlways((char const *)arg1);
3344     } catch (std::out_of_range& e) {
3345       {
3346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3347       };
3348     } catch (std::exception& e) {
3349       {
3350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3351       };
3352     } catch (...) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3355       };
3356     }
3357   }
3358 }
3359
3360
3361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3362   void * jresult ;
3363   Dali::Any *arg1 = 0 ;
3364   Dali::Any *result = 0 ;
3365
3366   arg1 = (Dali::Any *)jarg1;
3367   if (!arg1) {
3368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3369     return 0;
3370   }
3371   {
3372     try {
3373       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3374     } catch (std::out_of_range& e) {
3375       {
3376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (std::exception& e) {
3379       {
3380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3385       };
3386     }
3387   }
3388   jresult = (void *)result;
3389   return jresult;
3390 }
3391
3392
3393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3394   void * jresult ;
3395   Dali::Any *arg1 = (Dali::Any *) 0 ;
3396   Dali::Any *arg2 = 0 ;
3397   Dali::Any *result = 0 ;
3398
3399   arg1 = (Dali::Any *)jarg1;
3400   arg2 = (Dali::Any *)jarg2;
3401   if (!arg2) {
3402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3403     return 0;
3404   }
3405   {
3406     try {
3407       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3408     } catch (std::out_of_range& e) {
3409       {
3410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3411       };
3412     } catch (std::exception& e) {
3413       {
3414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3415       };
3416     } catch (...) {
3417       {
3418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3419       };
3420     }
3421   }
3422   jresult = (void *)result;
3423   return jresult;
3424 }
3425
3426
3427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3428   void * jresult ;
3429   Dali::Any *arg1 = (Dali::Any *) 0 ;
3430   std::type_info *result = 0 ;
3431
3432   arg1 = (Dali::Any *)jarg1;
3433   {
3434     try {
3435       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3436     } catch (std::out_of_range& e) {
3437       {
3438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (std::exception& e) {
3441       {
3442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3443       };
3444     } catch (...) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3447       };
3448     }
3449   }
3450   jresult = (void *)result;
3451   return jresult;
3452 }
3453
3454
3455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3456   unsigned int jresult ;
3457   Dali::Any *arg1 = (Dali::Any *) 0 ;
3458   bool result;
3459
3460   arg1 = (Dali::Any *)jarg1;
3461   {
3462     try {
3463       result = (bool)((Dali::Any const *)arg1)->Empty();
3464     } catch (std::out_of_range& e) {
3465       {
3466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3467       };
3468     } catch (std::exception& e) {
3469       {
3470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3471       };
3472     } catch (...) {
3473       {
3474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3475       };
3476     }
3477   }
3478   jresult = result;
3479   return jresult;
3480 }
3481
3482
3483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3484   void * jresult ;
3485   std::type_info *arg1 = 0 ;
3486   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3487   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3488   Dali::Any::AnyContainerBase *result = 0 ;
3489
3490   arg1 = (std::type_info *)jarg1;
3491   if (!arg1) {
3492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3493     return 0;
3494   }
3495   arg2 = (Dali::Any::CloneFunc)jarg2;
3496   arg3 = (Dali::Any::DeleteFunc)jarg3;
3497   {
3498     try {
3499       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (...) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3511       };
3512     }
3513   }
3514   jresult = (void *)result;
3515   return jresult;
3516 }
3517
3518
3519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3520   void * jresult ;
3521   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3522   std::type_info *result = 0 ;
3523
3524   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3525   {
3526     try {
3527       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3528     } catch (std::out_of_range& e) {
3529       {
3530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3531       };
3532     } catch (std::exception& e) {
3533       {
3534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3535       };
3536     } catch (...) {
3537       {
3538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3539       };
3540     }
3541   }
3542   jresult = (void *)result;
3543   return jresult;
3544 }
3545
3546
3547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3548   void * jresult ;
3549   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3550   ::std::type_info *result = 0 ;
3551
3552   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3553   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3554   jresult = (void *)result;
3555   return jresult;
3556 }
3557
3558
3559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3560   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3561   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3562
3563   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3564   arg2 = (Dali::Any::CloneFunc)jarg2;
3565   if (arg1) (arg1)->mCloneFunc = arg2;
3566 }
3567
3568
3569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3570   void * jresult ;
3571   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3572   Dali::Any::CloneFunc result;
3573
3574   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3575   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3576   jresult = (void *)result;
3577   return jresult;
3578 }
3579
3580
3581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3582   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3583   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3584
3585   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3586   arg2 = (Dali::Any::DeleteFunc)jarg2;
3587   if (arg1) (arg1)->mDeleteFunc = arg2;
3588 }
3589
3590
3591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3592   void * jresult ;
3593   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3594   Dali::Any::DeleteFunc result;
3595
3596   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3597   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3598   jresult = (void *)result;
3599   return jresult;
3600 }
3601
3602
3603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3604   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3605
3606   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3607   {
3608     try {
3609       delete arg1;
3610     } catch (std::out_of_range& e) {
3611       {
3612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (std::exception& e) {
3615       {
3616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624 }
3625
3626
3627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3628   Dali::Any *arg1 = (Dali::Any *) 0 ;
3629   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3630
3631   arg1 = (Dali::Any *)jarg1;
3632   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3633   if (arg1) (arg1)->mContainer = arg2;
3634 }
3635
3636
3637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3638   void * jresult ;
3639   Dali::Any *arg1 = (Dali::Any *) 0 ;
3640   Dali::Any::AnyContainerBase *result = 0 ;
3641
3642   arg1 = (Dali::Any *)jarg1;
3643   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3644   jresult = (void *)result;
3645   return jresult;
3646 }
3647
3648
3649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3650   char *arg1 = (char *) 0 ;
3651   char *arg2 = (char *) 0 ;
3652
3653   arg1 = (char *)jarg1;
3654   arg2 = (char *)jarg2;
3655   {
3656     try {
3657       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3658     } catch (std::out_of_range& e) {
3659       {
3660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3661       };
3662     } catch (std::exception& e) {
3663       {
3664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3665       };
3666     } catch (...) {
3667       {
3668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3669       };
3670     }
3671   }
3672 }
3673
3674
3675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3676   void * jresult ;
3677   char *arg1 = (char *) 0 ;
3678   char *arg2 = (char *) 0 ;
3679   Dali::DaliException *result = 0 ;
3680
3681   arg1 = (char *)jarg1;
3682   arg2 = (char *)jarg2;
3683   {
3684     try {
3685       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3686     } catch (std::out_of_range& e) {
3687       {
3688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3689       };
3690     } catch (std::exception& e) {
3691       {
3692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3693       };
3694     } catch (...) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3697       };
3698     }
3699   }
3700   jresult = (void *)result;
3701   return jresult;
3702 }
3703
3704
3705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3706   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3707   char *arg2 = (char *) 0 ;
3708
3709   arg1 = (Dali::DaliException *)jarg1;
3710   arg2 = (char *)jarg2;
3711   {
3712     if (arg2) {
3713       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3714       strcpy((char *)arg1->location, (const char *)arg2);
3715     } else {
3716       arg1->location = 0;
3717     }
3718   }
3719 }
3720
3721
3722 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3723   char * jresult ;
3724   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3725   char *result = 0 ;
3726
3727   arg1 = (Dali::DaliException *)jarg1;
3728   result = (char *) ((arg1)->location);
3729   jresult = SWIG_csharp_string_callback((const char *)result);
3730   return jresult;
3731 }
3732
3733
3734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3735   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3736   char *arg2 = (char *) 0 ;
3737
3738   arg1 = (Dali::DaliException *)jarg1;
3739   arg2 = (char *)jarg2;
3740   {
3741     if (arg2) {
3742       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3743       strcpy((char *)arg1->condition, (const char *)arg2);
3744     } else {
3745       arg1->condition = 0;
3746     }
3747   }
3748 }
3749
3750
3751 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3752   char * jresult ;
3753   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3754   char *result = 0 ;
3755
3756   arg1 = (Dali::DaliException *)jarg1;
3757   result = (char *) ((arg1)->condition);
3758   jresult = SWIG_csharp_string_callback((const char *)result);
3759   return jresult;
3760 }
3761
3762
3763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3764   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3765
3766   arg1 = (Dali::DaliException *)jarg1;
3767   {
3768     try {
3769       delete arg1;
3770     } catch (std::out_of_range& e) {
3771       {
3772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3773       };
3774     } catch (std::exception& e) {
3775       {
3776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3781       };
3782     }
3783   }
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3788   void * jresult ;
3789   Dali::Vector2 *result = 0 ;
3790
3791   {
3792     try {
3793       result = (Dali::Vector2 *)new Dali::Vector2();
3794     } catch (std::out_of_range& e) {
3795       {
3796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3797       };
3798     } catch (std::exception& e) {
3799       {
3800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3801       };
3802     } catch (...) {
3803       {
3804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3805       };
3806     }
3807   }
3808   jresult = (void *)result;
3809   return jresult;
3810 }
3811
3812
3813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3814   void * jresult ;
3815   float arg1 ;
3816   float arg2 ;
3817   Dali::Vector2 *result = 0 ;
3818
3819   arg1 = (float)jarg1;
3820   arg2 = (float)jarg2;
3821   {
3822     try {
3823       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3824     } catch (std::out_of_range& e) {
3825       {
3826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3827       };
3828     } catch (std::exception& e) {
3829       {
3830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3831       };
3832     } catch (...) {
3833       {
3834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3835       };
3836     }
3837   }
3838   jresult = (void *)result;
3839   return jresult;
3840 }
3841
3842
3843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3844   void * jresult ;
3845   float *arg1 = (float *) 0 ;
3846   Dali::Vector2 *result = 0 ;
3847
3848   arg1 = jarg1;
3849   {
3850     try {
3851       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3852     } catch (std::out_of_range& e) {
3853       {
3854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3855       };
3856     } catch (std::exception& e) {
3857       {
3858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3859       };
3860     } catch (...) {
3861       {
3862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3863       };
3864     }
3865   }
3866   jresult = (void *)result;
3867
3868
3869   return jresult;
3870 }
3871
3872
3873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3874   void * jresult ;
3875   Dali::Vector3 *arg1 = 0 ;
3876   Dali::Vector2 *result = 0 ;
3877
3878   arg1 = (Dali::Vector3 *)jarg1;
3879   if (!arg1) {
3880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3881     return 0;
3882   }
3883   {
3884     try {
3885       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3886     } catch (std::out_of_range& e) {
3887       {
3888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3889       };
3890     } catch (std::exception& e) {
3891       {
3892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3893       };
3894     } catch (...) {
3895       {
3896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3897       };
3898     }
3899   }
3900   jresult = (void *)result;
3901   return jresult;
3902 }
3903
3904
3905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3906   void * jresult ;
3907   Dali::Vector4 *arg1 = 0 ;
3908   Dali::Vector2 *result = 0 ;
3909
3910   arg1 = (Dali::Vector4 *)jarg1;
3911   if (!arg1) {
3912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3913     return 0;
3914   }
3915   {
3916     try {
3917       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3918     } catch (std::out_of_range& e) {
3919       {
3920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3921       };
3922     } catch (std::exception& e) {
3923       {
3924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3925       };
3926     } catch (...) {
3927       {
3928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3929       };
3930     }
3931   }
3932   jresult = (void *)result;
3933   return jresult;
3934 }
3935
3936
3937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3938   void * jresult ;
3939   Dali::Vector2 *result = 0 ;
3940
3941   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3942   jresult = (void *)result;
3943   return jresult;
3944 }
3945
3946
3947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3948   void * jresult ;
3949   Dali::Vector2 *result = 0 ;
3950
3951   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3952   jresult = (void *)result;
3953   return jresult;
3954 }
3955
3956
3957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3958   void * jresult ;
3959   Dali::Vector2 *result = 0 ;
3960
3961   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3968   void * jresult ;
3969   Dali::Vector2 *result = 0 ;
3970
3971   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3972   jresult = (void *)result;
3973   return jresult;
3974 }
3975
3976
3977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3978   void * jresult ;
3979   Dali::Vector2 *result = 0 ;
3980
3981   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3982   jresult = (void *)result;
3983   return jresult;
3984 }
3985
3986
3987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3988   void * jresult ;
3989   Dali::Vector2 *result = 0 ;
3990
3991   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3992   jresult = (void *)result;
3993   return jresult;
3994 }
3995
3996
3997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3998   void * jresult ;
3999   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4000   float *arg2 = (float *) 0 ;
4001   Dali::Vector2 *result = 0 ;
4002
4003   arg1 = (Dali::Vector2 *)jarg1;
4004   arg2 = jarg2;
4005   {
4006     try {
4007       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4008     } catch (std::out_of_range& e) {
4009       {
4010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4011       };
4012     } catch (std::exception& e) {
4013       {
4014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4015       };
4016     } catch (...) {
4017       {
4018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4019       };
4020     }
4021   }
4022   jresult = (void *)result;
4023
4024
4025   return jresult;
4026 }
4027
4028
4029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4030   void * jresult ;
4031   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4032   Dali::Vector3 *arg2 = 0 ;
4033   Dali::Vector2 *result = 0 ;
4034
4035   arg1 = (Dali::Vector2 *)jarg1;
4036   arg2 = (Dali::Vector3 *)jarg2;
4037   if (!arg2) {
4038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4039     return 0;
4040   }
4041   {
4042     try {
4043       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4044     } catch (std::out_of_range& e) {
4045       {
4046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4047       };
4048     } catch (std::exception& e) {
4049       {
4050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4051       };
4052     } catch (...) {
4053       {
4054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4055       };
4056     }
4057   }
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4064   void * jresult ;
4065   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4066   Dali::Vector4 *arg2 = 0 ;
4067   Dali::Vector2 *result = 0 ;
4068
4069   arg1 = (Dali::Vector2 *)jarg1;
4070   arg2 = (Dali::Vector4 *)jarg2;
4071   if (!arg2) {
4072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4073     return 0;
4074   }
4075   {
4076     try {
4077       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4078     } catch (std::out_of_range& e) {
4079       {
4080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4081       };
4082     } catch (std::exception& e) {
4083       {
4084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4085       };
4086     } catch (...) {
4087       {
4088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4089       };
4090     }
4091   }
4092   jresult = (void *)result;
4093   return jresult;
4094 }
4095
4096
4097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4098   void * jresult ;
4099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4100   Dali::Vector2 *arg2 = 0 ;
4101   Dali::Vector2 result;
4102
4103   arg1 = (Dali::Vector2 *)jarg1;
4104   arg2 = (Dali::Vector2 *)jarg2;
4105   if (!arg2) {
4106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4107     return 0;
4108   }
4109   {
4110     try {
4111       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4112     } catch (std::out_of_range& e) {
4113       {
4114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (std::exception& e) {
4117       {
4118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (...) {
4121       {
4122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4123       };
4124     }
4125   }
4126   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4127   return jresult;
4128 }
4129
4130
4131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4132   void * jresult ;
4133   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4134   Dali::Vector2 *arg2 = 0 ;
4135   Dali::Vector2 *result = 0 ;
4136
4137   arg1 = (Dali::Vector2 *)jarg1;
4138   arg2 = (Dali::Vector2 *)jarg2;
4139   if (!arg2) {
4140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4141     return 0;
4142   }
4143   {
4144     try {
4145       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4146     } catch (std::out_of_range& e) {
4147       {
4148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4149       };
4150     } catch (std::exception& e) {
4151       {
4152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4153       };
4154     } catch (...) {
4155       {
4156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4157       };
4158     }
4159   }
4160   jresult = (void *)result;
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4166   void * jresult ;
4167   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4168   Dali::Vector2 *arg2 = 0 ;
4169   Dali::Vector2 result;
4170
4171   arg1 = (Dali::Vector2 *)jarg1;
4172   arg2 = (Dali::Vector2 *)jarg2;
4173   if (!arg2) {
4174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4175     return 0;
4176   }
4177   {
4178     try {
4179       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4180     } catch (std::out_of_range& e) {
4181       {
4182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4183       };
4184     } catch (std::exception& e) {
4185       {
4186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4187       };
4188     } catch (...) {
4189       {
4190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4191       };
4192     }
4193   }
4194   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4195   return jresult;
4196 }
4197
4198
4199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4200   void * jresult ;
4201   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4202   Dali::Vector2 *arg2 = 0 ;
4203   Dali::Vector2 *result = 0 ;
4204
4205   arg1 = (Dali::Vector2 *)jarg1;
4206   arg2 = (Dali::Vector2 *)jarg2;
4207   if (!arg2) {
4208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4209     return 0;
4210   }
4211   {
4212     try {
4213       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4214     } catch (std::out_of_range& e) {
4215       {
4216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4217       };
4218     } catch (std::exception& e) {
4219       {
4220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4221       };
4222     } catch (...) {
4223       {
4224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4225       };
4226     }
4227   }
4228   jresult = (void *)result;
4229   return jresult;
4230 }
4231
4232
4233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4234   void * jresult ;
4235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4236   Dali::Vector2 *arg2 = 0 ;
4237   Dali::Vector2 result;
4238
4239   arg1 = (Dali::Vector2 *)jarg1;
4240   arg2 = (Dali::Vector2 *)jarg2;
4241   if (!arg2) {
4242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4243     return 0;
4244   }
4245   {
4246     try {
4247       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4248     } catch (std::out_of_range& e) {
4249       {
4250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4251       };
4252     } catch (std::exception& e) {
4253       {
4254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4255       };
4256     } catch (...) {
4257       {
4258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4259       };
4260     }
4261   }
4262   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4263   return jresult;
4264 }
4265
4266
4267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4268   void * jresult ;
4269   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4270   float arg2 ;
4271   Dali::Vector2 result;
4272
4273   arg1 = (Dali::Vector2 *)jarg1;
4274   arg2 = (float)jarg2;
4275   {
4276     try {
4277       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4278     } catch (std::out_of_range& e) {
4279       {
4280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4281       };
4282     } catch (std::exception& e) {
4283       {
4284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4285       };
4286     } catch (...) {
4287       {
4288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4289       };
4290     }
4291   }
4292   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4293   return jresult;
4294 }
4295
4296
4297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4298   void * jresult ;
4299   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4300   Dali::Vector2 *arg2 = 0 ;
4301   Dali::Vector2 *result = 0 ;
4302
4303   arg1 = (Dali::Vector2 *)jarg1;
4304   arg2 = (Dali::Vector2 *)jarg2;
4305   if (!arg2) {
4306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4307     return 0;
4308   }
4309   {
4310     try {
4311       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4312     } catch (std::out_of_range& e) {
4313       {
4314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4315       };
4316     } catch (std::exception& e) {
4317       {
4318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4319       };
4320     } catch (...) {
4321       {
4322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4323       };
4324     }
4325   }
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4332   void * jresult ;
4333   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4334   float arg2 ;
4335   Dali::Vector2 *result = 0 ;
4336
4337   arg1 = (Dali::Vector2 *)jarg1;
4338   arg2 = (float)jarg2;
4339   {
4340     try {
4341       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4342     } catch (std::out_of_range& e) {
4343       {
4344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (std::exception& e) {
4347       {
4348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356   jresult = (void *)result;
4357   return jresult;
4358 }
4359
4360
4361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4362   void * jresult ;
4363   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4364   Dali::Vector2 *arg2 = 0 ;
4365   Dali::Vector2 result;
4366
4367   arg1 = (Dali::Vector2 *)jarg1;
4368   arg2 = (Dali::Vector2 *)jarg2;
4369   if (!arg2) {
4370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4371     return 0;
4372   }
4373   {
4374     try {
4375       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4376     } catch (std::out_of_range& e) {
4377       {
4378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (std::exception& e) {
4381       {
4382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4396   void * jresult ;
4397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4398   float arg2 ;
4399   Dali::Vector2 result;
4400
4401   arg1 = (Dali::Vector2 *)jarg1;
4402   arg2 = (float)jarg2;
4403   {
4404     try {
4405       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4406     } catch (std::out_of_range& e) {
4407       {
4408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4409       };
4410     } catch (std::exception& e) {
4411       {
4412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4413       };
4414     } catch (...) {
4415       {
4416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4417       };
4418     }
4419   }
4420   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4426   void * jresult ;
4427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4428   Dali::Vector2 *arg2 = 0 ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   arg1 = (Dali::Vector2 *)jarg1;
4432   arg2 = (Dali::Vector2 *)jarg2;
4433   if (!arg2) {
4434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4435     return 0;
4436   }
4437   {
4438     try {
4439       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4440     } catch (std::out_of_range& e) {
4441       {
4442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4443       };
4444     } catch (std::exception& e) {
4445       {
4446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4447       };
4448     } catch (...) {
4449       {
4450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4451       };
4452     }
4453   }
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float arg2 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = (float)jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (...) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4481       };
4482     }
4483   }
4484   jresult = (void *)result;
4485   return jresult;
4486 }
4487
4488
4489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4490   void * jresult ;
4491   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4492   Dali::Vector2 result;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   {
4496     try {
4497       result = ((Dali::Vector2 const *)arg1)->operator -();
4498     } catch (std::out_of_range& e) {
4499       {
4500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4501       };
4502     } catch (std::exception& e) {
4503       {
4504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (...) {
4507       {
4508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4509       };
4510     }
4511   }
4512   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4513   return jresult;
4514 }
4515
4516
4517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4518   unsigned int jresult ;
4519   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4520   Dali::Vector2 *arg2 = 0 ;
4521   bool result;
4522
4523   arg1 = (Dali::Vector2 *)jarg1;
4524   arg2 = (Dali::Vector2 *)jarg2;
4525   if (!arg2) {
4526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4527     return 0;
4528   }
4529   {
4530     try {
4531       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4532     } catch (std::out_of_range& e) {
4533       {
4534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4535       };
4536     } catch (std::exception& e) {
4537       {
4538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4539       };
4540     } catch (...) {
4541       {
4542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4543       };
4544     }
4545   }
4546   jresult = result;
4547   return jresult;
4548 }
4549
4550
4551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4552   unsigned int jresult ;
4553   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4554   Dali::Vector2 *arg2 = 0 ;
4555   bool result;
4556
4557   arg1 = (Dali::Vector2 *)jarg1;
4558   arg2 = (Dali::Vector2 *)jarg2;
4559   if (!arg2) {
4560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4561     return 0;
4562   }
4563   {
4564     try {
4565       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4566     } catch (std::out_of_range& e) {
4567       {
4568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4569       };
4570     } catch (std::exception& e) {
4571       {
4572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (...) {
4575       {
4576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4577       };
4578     }
4579   }
4580   jresult = result;
4581   return jresult;
4582 }
4583
4584
4585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4586   float jresult ;
4587   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4588   unsigned int arg2 ;
4589   float *result = 0 ;
4590
4591   arg1 = (Dali::Vector2 *)jarg1;
4592   arg2 = (unsigned int)jarg2;
4593   {
4594     try {
4595       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4596     } catch (std::out_of_range& e) {
4597       {
4598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4599       };
4600     } catch (std::exception& e) {
4601       {
4602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4603       };
4604     } catch (...) {
4605       {
4606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4607       };
4608     }
4609   }
4610   jresult = *result;
4611   return jresult;
4612 }
4613
4614
4615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4616   float jresult ;
4617   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4618   float result;
4619
4620   arg1 = (Dali::Vector2 *)jarg1;
4621   {
4622     try {
4623       result = (float)((Dali::Vector2 const *)arg1)->Length();
4624     } catch (std::out_of_range& e) {
4625       {
4626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (std::exception& e) {
4629       {
4630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638   jresult = result;
4639   return jresult;
4640 }
4641
4642
4643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4644   float jresult ;
4645   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4646   float result;
4647
4648   arg1 = (Dali::Vector2 *)jarg1;
4649   {
4650     try {
4651       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4652     } catch (std::out_of_range& e) {
4653       {
4654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4655       };
4656     } catch (std::exception& e) {
4657       {
4658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4659       };
4660     } catch (...) {
4661       {
4662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4663       };
4664     }
4665   }
4666   jresult = result;
4667   return jresult;
4668 }
4669
4670
4671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4672   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4673
4674   arg1 = (Dali::Vector2 *)jarg1;
4675   {
4676     try {
4677       (arg1)->Normalize();
4678     } catch (std::out_of_range& e) {
4679       {
4680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4681       };
4682     } catch (std::exception& e) {
4683       {
4684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4685       };
4686     } catch (...) {
4687       {
4688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4689       };
4690     }
4691   }
4692 }
4693
4694
4695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4696   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4697   Dali::Vector2 *arg2 = 0 ;
4698   Dali::Vector2 *arg3 = 0 ;
4699
4700   arg1 = (Dali::Vector2 *)jarg1;
4701   arg2 = (Dali::Vector2 *)jarg2;
4702   if (!arg2) {
4703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4704     return ;
4705   }
4706   arg3 = (Dali::Vector2 *)jarg3;
4707   if (!arg3) {
4708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4709     return ;
4710   }
4711   {
4712     try {
4713       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4714     } catch (std::out_of_range& e) {
4715       {
4716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4717       };
4718     } catch (std::exception& e) {
4719       {
4720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4721       };
4722     } catch (...) {
4723       {
4724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4725       };
4726     }
4727   }
4728 }
4729
4730
4731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4732   void * jresult ;
4733   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4734   float *result = 0 ;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   {
4738     try {
4739       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4740     } catch (std::out_of_range& e) {
4741       {
4742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4743       };
4744     } catch (std::exception& e) {
4745       {
4746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (...) {
4749       {
4750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4751       };
4752     }
4753   }
4754   jresult = (void *)result;
4755   return jresult;
4756 }
4757
4758
4759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4760   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4761   float arg2 ;
4762
4763   arg1 = (Dali::Vector2 *)jarg1;
4764   arg2 = (float)jarg2;
4765   if (arg1) (arg1)->x = arg2;
4766 }
4767
4768
4769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4770   float jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float result;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   result = (float) ((arg1)->x);
4776   jresult = result;
4777   return jresult;
4778 }
4779
4780
4781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4782   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4783   float arg2 ;
4784
4785   arg1 = (Dali::Vector2 *)jarg1;
4786   arg2 = (float)jarg2;
4787   if (arg1) (arg1)->width = arg2;
4788 }
4789
4790
4791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4792   float jresult ;
4793   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4794   float result;
4795
4796   arg1 = (Dali::Vector2 *)jarg1;
4797   result = (float) ((arg1)->width);
4798   jresult = result;
4799   return jresult;
4800 }
4801
4802
4803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   float arg2 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (float)jarg2;
4809   if (arg1) (arg1)->y = arg2;
4810 }
4811
4812
4813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4814   float jresult ;
4815   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4816   float result;
4817
4818   arg1 = (Dali::Vector2 *)jarg1;
4819   result = (float) ((arg1)->y);
4820   jresult = result;
4821   return jresult;
4822 }
4823
4824
4825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4826   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4827   float arg2 ;
4828
4829   arg1 = (Dali::Vector2 *)jarg1;
4830   arg2 = (float)jarg2;
4831   if (arg1) (arg1)->height = arg2;
4832 }
4833
4834
4835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4836   float jresult ;
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float result;
4839
4840   arg1 = (Dali::Vector2 *)jarg1;
4841   result = (float) ((arg1)->height);
4842   jresult = result;
4843   return jresult;
4844 }
4845
4846
4847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4848   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4849
4850   arg1 = (Dali::Vector2 *)jarg1;
4851   {
4852     try {
4853       delete arg1;
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4861       };
4862     } catch (...) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4865       };
4866     }
4867   }
4868 }
4869
4870
4871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4872   void * jresult ;
4873   Dali::Vector2 *arg1 = 0 ;
4874   Dali::Vector2 *arg2 = 0 ;
4875   Dali::Vector2 result;
4876
4877   arg1 = (Dali::Vector2 *)jarg1;
4878   if (!arg1) {
4879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4880     return 0;
4881   }
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (...) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4901       };
4902     }
4903   }
4904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4905   return jresult;
4906 }
4907
4908
4909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4910   void * jresult ;
4911   Dali::Vector2 *arg1 = 0 ;
4912   Dali::Vector2 *arg2 = 0 ;
4913   Dali::Vector2 result;
4914
4915   arg1 = (Dali::Vector2 *)jarg1;
4916   if (!arg1) {
4917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4918     return 0;
4919   }
4920   arg2 = (Dali::Vector2 *)jarg2;
4921   if (!arg2) {
4922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4923     return 0;
4924   }
4925   {
4926     try {
4927       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (...) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4939       };
4940     }
4941   }
4942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4948   void * jresult ;
4949   Dali::Vector2 *arg1 = 0 ;
4950   float *arg2 = 0 ;
4951   float *arg3 = 0 ;
4952   float temp2 ;
4953   float temp3 ;
4954   Dali::Vector2 result;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   if (!arg1) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   temp2 = (float)jarg2;
4962   arg2 = &temp2;
4963   temp3 = (float)jarg3;
4964   arg3 = &temp3;
4965   {
4966     try {
4967       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4968     } catch (std::out_of_range& e) {
4969       {
4970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (std::exception& e) {
4973       {
4974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4983   return jresult;
4984 }
4985
4986
4987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4988   void * jresult ;
4989   Dali::Vector3 *result = 0 ;
4990
4991   {
4992     try {
4993       result = (Dali::Vector3 *)new Dali::Vector3();
4994     } catch (std::out_of_range& e) {
4995       {
4996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (std::exception& e) {
4999       {
5000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (...) {
5003       {
5004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5005       };
5006     }
5007   }
5008   jresult = (void *)result;
5009   return jresult;
5010 }
5011
5012
5013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5014   void * jresult ;
5015   float arg1 ;
5016   float arg2 ;
5017   float arg3 ;
5018   Dali::Vector3 *result = 0 ;
5019
5020   arg1 = (float)jarg1;
5021   arg2 = (float)jarg2;
5022   arg3 = (float)jarg3;
5023   {
5024     try {
5025       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5026     } catch (std::out_of_range& e) {
5027       {
5028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (std::exception& e) {
5031       {
5032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (...) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5037       };
5038     }
5039   }
5040   jresult = (void *)result;
5041   return jresult;
5042 }
5043
5044
5045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5046   void * jresult ;
5047   float *arg1 = (float *) 0 ;
5048   Dali::Vector3 *result = 0 ;
5049
5050   arg1 = jarg1;
5051   {
5052     try {
5053       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5054     } catch (std::out_of_range& e) {
5055       {
5056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5057       };
5058     } catch (std::exception& e) {
5059       {
5060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5061       };
5062     } catch (...) {
5063       {
5064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5065       };
5066     }
5067   }
5068   jresult = (void *)result;
5069
5070
5071   return jresult;
5072 }
5073
5074
5075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5076   void * jresult ;
5077   Dali::Vector2 *arg1 = 0 ;
5078   Dali::Vector3 *result = 0 ;
5079
5080   arg1 = (Dali::Vector2 *)jarg1;
5081   if (!arg1) {
5082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5083     return 0;
5084   }
5085   {
5086     try {
5087       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5088     } catch (std::out_of_range& e) {
5089       {
5090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5091       };
5092     } catch (std::exception& e) {
5093       {
5094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5095       };
5096     } catch (...) {
5097       {
5098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5099       };
5100     }
5101   }
5102   jresult = (void *)result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5108   void * jresult ;
5109   Dali::Vector4 *arg1 = 0 ;
5110   Dali::Vector3 *result = 0 ;
5111
5112   arg1 = (Dali::Vector4 *)jarg1;
5113   if (!arg1) {
5114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5115     return 0;
5116   }
5117   {
5118     try {
5119       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5120     } catch (std::out_of_range& e) {
5121       {
5122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5123       };
5124     } catch (std::exception& e) {
5125       {
5126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5127       };
5128     } catch (...) {
5129       {
5130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5131       };
5132     }
5133   }
5134   jresult = (void *)result;
5135   return jresult;
5136 }
5137
5138
5139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5140   void * jresult ;
5141   Dali::Vector3 *result = 0 ;
5142
5143   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5144   jresult = (void *)result;
5145   return jresult;
5146 }
5147
5148
5149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5150   void * jresult ;
5151   Dali::Vector3 *result = 0 ;
5152
5153   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5154   jresult = (void *)result;
5155   return jresult;
5156 }
5157
5158
5159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5160   void * jresult ;
5161   Dali::Vector3 *result = 0 ;
5162
5163   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5164   jresult = (void *)result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5170   void * jresult ;
5171   Dali::Vector3 *result = 0 ;
5172
5173   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5174   jresult = (void *)result;
5175   return jresult;
5176 }
5177
5178
5179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5180   void * jresult ;
5181   Dali::Vector3 *result = 0 ;
5182
5183   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5184   jresult = (void *)result;
5185   return jresult;
5186 }
5187
5188
5189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5190   void * jresult ;
5191   Dali::Vector3 *result = 0 ;
5192
5193   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5194   jresult = (void *)result;
5195   return jresult;
5196 }
5197
5198
5199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5200   void * jresult ;
5201   Dali::Vector3 *result = 0 ;
5202
5203   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5204   jresult = (void *)result;
5205   return jresult;
5206 }
5207
5208
5209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5210   void * jresult ;
5211   Dali::Vector3 *result = 0 ;
5212
5213   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5214   jresult = (void *)result;
5215   return jresult;
5216 }
5217
5218
5219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5220   void * jresult ;
5221   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5222   float *arg2 = (float *) 0 ;
5223   Dali::Vector3 *result = 0 ;
5224
5225   arg1 = (Dali::Vector3 *)jarg1;
5226   arg2 = jarg2;
5227   {
5228     try {
5229       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5230     } catch (std::out_of_range& e) {
5231       {
5232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5233       };
5234     } catch (std::exception& e) {
5235       {
5236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5237       };
5238     } catch (...) {
5239       {
5240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5241       };
5242     }
5243   }
5244   jresult = (void *)result;
5245
5246
5247   return jresult;
5248 }
5249
5250
5251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5252   void * jresult ;
5253   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5254   Dali::Vector2 *arg2 = 0 ;
5255   Dali::Vector3 *result = 0 ;
5256
5257   arg1 = (Dali::Vector3 *)jarg1;
5258   arg2 = (Dali::Vector2 *)jarg2;
5259   if (!arg2) {
5260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5261     return 0;
5262   }
5263   {
5264     try {
5265       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5266     } catch (std::out_of_range& e) {
5267       {
5268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5269       };
5270     } catch (std::exception& e) {
5271       {
5272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5273       };
5274     } catch (...) {
5275       {
5276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5277       };
5278     }
5279   }
5280   jresult = (void *)result;
5281   return jresult;
5282 }
5283
5284
5285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5286   void * jresult ;
5287   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5288   Dali::Vector4 *arg2 = 0 ;
5289   Dali::Vector3 *result = 0 ;
5290
5291   arg1 = (Dali::Vector3 *)jarg1;
5292   arg2 = (Dali::Vector4 *)jarg2;
5293   if (!arg2) {
5294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5295     return 0;
5296   }
5297   {
5298     try {
5299       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5300     } catch (std::out_of_range& e) {
5301       {
5302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5303       };
5304     } catch (std::exception& e) {
5305       {
5306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5307       };
5308     } catch (...) {
5309       {
5310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5311       };
5312     }
5313   }
5314   jresult = (void *)result;
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5320   void * jresult ;
5321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5322   Dali::Vector3 *arg2 = 0 ;
5323   Dali::Vector3 result;
5324
5325   arg1 = (Dali::Vector3 *)jarg1;
5326   arg2 = (Dali::Vector3 *)jarg2;
5327   if (!arg2) {
5328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5329     return 0;
5330   }
5331   {
5332     try {
5333       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5334     } catch (std::out_of_range& e) {
5335       {
5336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (std::exception& e) {
5339       {
5340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5341       };
5342     } catch (...) {
5343       {
5344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5345       };
5346     }
5347   }
5348   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5349   return jresult;
5350 }
5351
5352
5353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5354   void * jresult ;
5355   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5356   Dali::Vector3 *arg2 = 0 ;
5357   Dali::Vector3 *result = 0 ;
5358
5359   arg1 = (Dali::Vector3 *)jarg1;
5360   arg2 = (Dali::Vector3 *)jarg2;
5361   if (!arg2) {
5362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5363     return 0;
5364   }
5365   {
5366     try {
5367       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5368     } catch (std::out_of_range& e) {
5369       {
5370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5371       };
5372     } catch (std::exception& e) {
5373       {
5374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5375       };
5376     } catch (...) {
5377       {
5378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5379       };
5380     }
5381   }
5382   jresult = (void *)result;
5383   return jresult;
5384 }
5385
5386
5387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5388   void * jresult ;
5389   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5390   Dali::Vector3 *arg2 = 0 ;
5391   Dali::Vector3 result;
5392
5393   arg1 = (Dali::Vector3 *)jarg1;
5394   arg2 = (Dali::Vector3 *)jarg2;
5395   if (!arg2) {
5396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5397     return 0;
5398   }
5399   {
5400     try {
5401       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5402     } catch (std::out_of_range& e) {
5403       {
5404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5405       };
5406     } catch (std::exception& e) {
5407       {
5408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5409       };
5410     } catch (...) {
5411       {
5412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5413       };
5414     }
5415   }
5416   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5417   return jresult;
5418 }
5419
5420
5421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5422   void * jresult ;
5423   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5424   Dali::Vector3 *arg2 = 0 ;
5425   Dali::Vector3 *result = 0 ;
5426
5427   arg1 = (Dali::Vector3 *)jarg1;
5428   arg2 = (Dali::Vector3 *)jarg2;
5429   if (!arg2) {
5430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5431     return 0;
5432   }
5433   {
5434     try {
5435       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5443       };
5444     } catch (...) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5447       };
5448     }
5449   }
5450   jresult = (void *)result;
5451   return jresult;
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5458   Dali::Vector3 *arg2 = 0 ;
5459   Dali::Vector3 result;
5460
5461   arg1 = (Dali::Vector3 *)jarg1;
5462   arg2 = (Dali::Vector3 *)jarg2;
5463   if (!arg2) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5465     return 0;
5466   }
5467   {
5468     try {
5469       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5470     } catch (std::out_of_range& e) {
5471       {
5472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5473       };
5474     } catch (std::exception& e) {
5475       {
5476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (...) {
5479       {
5480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5481       };
5482     }
5483   }
5484   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5485   return jresult;
5486 }
5487
5488
5489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5490   void * jresult ;
5491   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5492   float arg2 ;
5493   Dali::Vector3 result;
5494
5495   arg1 = (Dali::Vector3 *)jarg1;
5496   arg2 = (float)jarg2;
5497   {
5498     try {
5499       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5500     } catch (std::out_of_range& e) {
5501       {
5502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5503       };
5504     } catch (std::exception& e) {
5505       {
5506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5507       };
5508     } catch (...) {
5509       {
5510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5511       };
5512     }
5513   }
5514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5515   return jresult;
5516 }
5517
5518
5519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5520   void * jresult ;
5521   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5522   Dali::Vector3 *arg2 = 0 ;
5523   Dali::Vector3 *result = 0 ;
5524
5525   arg1 = (Dali::Vector3 *)jarg1;
5526   arg2 = (Dali::Vector3 *)jarg2;
5527   if (!arg2) {
5528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5529     return 0;
5530   }
5531   {
5532     try {
5533       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5534     } catch (std::out_of_range& e) {
5535       {
5536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5537       };
5538     } catch (std::exception& e) {
5539       {
5540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5541       };
5542     } catch (...) {
5543       {
5544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5545       };
5546     }
5547   }
5548   jresult = (void *)result;
5549   return jresult;
5550 }
5551
5552
5553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5554   void * jresult ;
5555   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5556   float arg2 ;
5557   Dali::Vector3 *result = 0 ;
5558
5559   arg1 = (Dali::Vector3 *)jarg1;
5560   arg2 = (float)jarg2;
5561   {
5562     try {
5563       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5564     } catch (std::out_of_range& e) {
5565       {
5566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5567       };
5568     } catch (std::exception& e) {
5569       {
5570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5571       };
5572     } catch (...) {
5573       {
5574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5575       };
5576     }
5577   }
5578   jresult = (void *)result;
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5584   void * jresult ;
5585   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5586   Dali::Quaternion *arg2 = 0 ;
5587   Dali::Vector3 *result = 0 ;
5588
5589   arg1 = (Dali::Vector3 *)jarg1;
5590   arg2 = (Dali::Quaternion *)jarg2;
5591   if (!arg2) {
5592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5593     return 0;
5594   }
5595   {
5596     try {
5597       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5598     } catch (std::out_of_range& e) {
5599       {
5600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (std::exception& e) {
5603       {
5604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5618   void * jresult ;
5619   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5620   Dali::Vector3 *arg2 = 0 ;
5621   Dali::Vector3 result;
5622
5623   arg1 = (Dali::Vector3 *)jarg1;
5624   arg2 = (Dali::Vector3 *)jarg2;
5625   if (!arg2) {
5626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5627     return 0;
5628   }
5629   {
5630     try {
5631       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5632     } catch (std::out_of_range& e) {
5633       {
5634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (std::exception& e) {
5637       {
5638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5639       };
5640     } catch (...) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5643       };
5644     }
5645   }
5646   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5652   void * jresult ;
5653   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5654   float arg2 ;
5655   Dali::Vector3 result;
5656
5657   arg1 = (Dali::Vector3 *)jarg1;
5658   arg2 = (float)jarg2;
5659   {
5660     try {
5661       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5662     } catch (std::out_of_range& e) {
5663       {
5664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (std::exception& e) {
5667       {
5668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5677   return jresult;
5678 }
5679
5680
5681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5682   void * jresult ;
5683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5684   Dali::Vector3 *arg2 = 0 ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   arg1 = (Dali::Vector3 *)jarg1;
5688   arg2 = (Dali::Vector3 *)jarg2;
5689   if (!arg2) {
5690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5691     return 0;
5692   }
5693   {
5694     try {
5695       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5696     } catch (std::out_of_range& e) {
5697       {
5698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (std::exception& e) {
5701       {
5702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710   jresult = (void *)result;
5711   return jresult;
5712 }
5713
5714
5715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5716   void * jresult ;
5717   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5718   float arg2 ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   arg1 = (Dali::Vector3 *)jarg1;
5722   arg2 = (float)jarg2;
5723   {
5724     try {
5725       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5726     } catch (std::out_of_range& e) {
5727       {
5728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5729       };
5730     } catch (std::exception& e) {
5731       {
5732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5733       };
5734     } catch (...) {
5735       {
5736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5737       };
5738     }
5739   }
5740   jresult = (void *)result;
5741   return jresult;
5742 }
5743
5744
5745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5746   void * jresult ;
5747   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5748   Dali::Vector3 result;
5749
5750   arg1 = (Dali::Vector3 *)jarg1;
5751   {
5752     try {
5753       result = ((Dali::Vector3 const *)arg1)->operator -();
5754     } catch (std::out_of_range& e) {
5755       {
5756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5757       };
5758     } catch (std::exception& e) {
5759       {
5760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5761       };
5762     } catch (...) {
5763       {
5764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5765       };
5766     }
5767   }
5768   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5774   unsigned int jresult ;
5775   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5776   Dali::Vector3 *arg2 = 0 ;
5777   bool result;
5778
5779   arg1 = (Dali::Vector3 *)jarg1;
5780   arg2 = (Dali::Vector3 *)jarg2;
5781   if (!arg2) {
5782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5783     return 0;
5784   }
5785   {
5786     try {
5787       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5788     } catch (std::out_of_range& e) {
5789       {
5790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5791       };
5792     } catch (std::exception& e) {
5793       {
5794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5795       };
5796     } catch (...) {
5797       {
5798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5799       };
5800     }
5801   }
5802   jresult = result;
5803   return jresult;
5804 }
5805
5806
5807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5808   unsigned int jresult ;
5809   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5810   Dali::Vector3 *arg2 = 0 ;
5811   bool result;
5812
5813   arg1 = (Dali::Vector3 *)jarg1;
5814   arg2 = (Dali::Vector3 *)jarg2;
5815   if (!arg2) {
5816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5817     return 0;
5818   }
5819   {
5820     try {
5821       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5822     } catch (std::out_of_range& e) {
5823       {
5824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5825       };
5826     } catch (std::exception& e) {
5827       {
5828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5829       };
5830     } catch (...) {
5831       {
5832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5833       };
5834     }
5835   }
5836   jresult = result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5842   float jresult ;
5843   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5844   unsigned int arg2 ;
5845   float *result = 0 ;
5846
5847   arg1 = (Dali::Vector3 *)jarg1;
5848   arg2 = (unsigned int)jarg2;
5849   {
5850     try {
5851       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5852     } catch (std::out_of_range& e) {
5853       {
5854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (std::exception& e) {
5857       {
5858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (...) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5863       };
5864     }
5865   }
5866   jresult = *result;
5867   return jresult;
5868 }
5869
5870
5871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5872   float jresult ;
5873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5874   Dali::Vector3 *arg2 = 0 ;
5875   float result;
5876
5877   arg1 = (Dali::Vector3 *)jarg1;
5878   arg2 = (Dali::Vector3 *)jarg2;
5879   if (!arg2) {
5880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5881     return 0;
5882   }
5883   {
5884     try {
5885       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5886     } catch (std::out_of_range& e) {
5887       {
5888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (std::exception& e) {
5891       {
5892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (...) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5897       };
5898     }
5899   }
5900   jresult = result;
5901   return jresult;
5902 }
5903
5904
5905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5906   void * jresult ;
5907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5908   Dali::Vector3 *arg2 = 0 ;
5909   Dali::Vector3 result;
5910
5911   arg1 = (Dali::Vector3 *)jarg1;
5912   arg2 = (Dali::Vector3 *)jarg2;
5913   if (!arg2) {
5914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5915     return 0;
5916   }
5917   {
5918     try {
5919       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5920     } catch (std::out_of_range& e) {
5921       {
5922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5923       };
5924     } catch (std::exception& e) {
5925       {
5926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5927       };
5928     } catch (...) {
5929       {
5930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5931       };
5932     }
5933   }
5934   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5935   return jresult;
5936 }
5937
5938
5939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5940   float jresult ;
5941   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5942   float result;
5943
5944   arg1 = (Dali::Vector3 *)jarg1;
5945   {
5946     try {
5947       result = (float)((Dali::Vector3 const *)arg1)->Length();
5948     } catch (std::out_of_range& e) {
5949       {
5950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5951       };
5952     } catch (std::exception& e) {
5953       {
5954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (...) {
5957       {
5958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5959       };
5960     }
5961   }
5962   jresult = result;
5963   return jresult;
5964 }
5965
5966
5967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5968   float jresult ;
5969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5970   float result;
5971
5972   arg1 = (Dali::Vector3 *)jarg1;
5973   {
5974     try {
5975       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (...) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5987       };
5988     }
5989   }
5990   jresult = result;
5991   return jresult;
5992 }
5993
5994
5995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   {
6000     try {
6001       (arg1)->Normalize();
6002     } catch (std::out_of_range& e) {
6003       {
6004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6005       };
6006     } catch (std::exception& e) {
6007       {
6008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6009       };
6010     } catch (...) {
6011       {
6012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6013       };
6014     }
6015   }
6016 }
6017
6018
6019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6021   Dali::Vector3 *arg2 = 0 ;
6022   Dali::Vector3 *arg3 = 0 ;
6023
6024   arg1 = (Dali::Vector3 *)jarg1;
6025   arg2 = (Dali::Vector3 *)jarg2;
6026   if (!arg2) {
6027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6028     return ;
6029   }
6030   arg3 = (Dali::Vector3 *)jarg3;
6031   if (!arg3) {
6032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6033     return ;
6034   }
6035   {
6036     try {
6037       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6045       };
6046     } catch (...) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6049       };
6050     }
6051   }
6052 }
6053
6054
6055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6056   void * jresult ;
6057   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6058   float *result = 0 ;
6059
6060   arg1 = (Dali::Vector3 *)jarg1;
6061   {
6062     try {
6063       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6064     } catch (std::out_of_range& e) {
6065       {
6066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6067       };
6068     } catch (std::exception& e) {
6069       {
6070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6071       };
6072     } catch (...) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6075       };
6076     }
6077   }
6078   jresult = (void *)result;
6079   return jresult;
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6084   void * jresult ;
6085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6086   Dali::Vector2 *result = 0 ;
6087
6088   arg1 = (Dali::Vector3 *)jarg1;
6089   {
6090     try {
6091       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6092     } catch (std::out_of_range& e) {
6093       {
6094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6095       };
6096     } catch (std::exception& e) {
6097       {
6098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6099       };
6100     } catch (...) {
6101       {
6102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6103       };
6104     }
6105   }
6106   jresult = (void *)result;
6107   return jresult;
6108 }
6109
6110
6111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6112   void * jresult ;
6113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6114   Dali::Vector2 *result = 0 ;
6115
6116   arg1 = (Dali::Vector3 *)jarg1;
6117   {
6118     try {
6119       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6120     } catch (std::out_of_range& e) {
6121       {
6122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (std::exception& e) {
6125       {
6126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (...) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6131       };
6132     }
6133   }
6134   jresult = (void *)result;
6135   return jresult;
6136 }
6137
6138
6139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6140   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6141   float arg2 ;
6142
6143   arg1 = (Dali::Vector3 *)jarg1;
6144   arg2 = (float)jarg2;
6145   if (arg1) (arg1)->x = arg2;
6146 }
6147
6148
6149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6150   float jresult ;
6151   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6152   float result;
6153
6154   arg1 = (Dali::Vector3 *)jarg1;
6155   result = (float) ((arg1)->x);
6156   jresult = result;
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6162   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6163   float arg2 ;
6164
6165   arg1 = (Dali::Vector3 *)jarg1;
6166   arg2 = (float)jarg2;
6167   if (arg1) (arg1)->width = arg2;
6168 }
6169
6170
6171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6172   float jresult ;
6173   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6174   float result;
6175
6176   arg1 = (Dali::Vector3 *)jarg1;
6177   result = (float) ((arg1)->width);
6178   jresult = result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6184   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6185   float arg2 ;
6186
6187   arg1 = (Dali::Vector3 *)jarg1;
6188   arg2 = (float)jarg2;
6189   if (arg1) (arg1)->r = arg2;
6190 }
6191
6192
6193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6194   float jresult ;
6195   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6196   float result;
6197
6198   arg1 = (Dali::Vector3 *)jarg1;
6199   result = (float) ((arg1)->r);
6200   jresult = result;
6201   return jresult;
6202 }
6203
6204
6205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6206   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6207   float arg2 ;
6208
6209   arg1 = (Dali::Vector3 *)jarg1;
6210   arg2 = (float)jarg2;
6211   if (arg1) (arg1)->y = arg2;
6212 }
6213
6214
6215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6216   float jresult ;
6217   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6218   float result;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   result = (float) ((arg1)->y);
6222   jresult = result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6228   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6229   float arg2 ;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   arg2 = (float)jarg2;
6233   if (arg1) (arg1)->height = arg2;
6234 }
6235
6236
6237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6238   float jresult ;
6239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6240   float result;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   result = (float) ((arg1)->height);
6244   jresult = result;
6245   return jresult;
6246 }
6247
6248
6249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6251   float arg2 ;
6252
6253   arg1 = (Dali::Vector3 *)jarg1;
6254   arg2 = (float)jarg2;
6255   if (arg1) (arg1)->g = arg2;
6256 }
6257
6258
6259 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6260   float jresult ;
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   float result;
6263
6264   arg1 = (Dali::Vector3 *)jarg1;
6265   result = (float) ((arg1)->g);
6266   jresult = result;
6267   return jresult;
6268 }
6269
6270
6271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   float arg2 ;
6274
6275   arg1 = (Dali::Vector3 *)jarg1;
6276   arg2 = (float)jarg2;
6277   if (arg1) (arg1)->z = arg2;
6278 }
6279
6280
6281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6282   float jresult ;
6283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6284   float result;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   result = (float) ((arg1)->z);
6288   jresult = result;
6289   return jresult;
6290 }
6291
6292
6293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float arg2 ;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   arg2 = (float)jarg2;
6299   if (arg1) (arg1)->depth = arg2;
6300 }
6301
6302
6303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6304   float jresult ;
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   float result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   result = (float) ((arg1)->depth);
6310   jresult = result;
6311   return jresult;
6312 }
6313
6314
6315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6317   float arg2 ;
6318
6319   arg1 = (Dali::Vector3 *)jarg1;
6320   arg2 = (float)jarg2;
6321   if (arg1) (arg1)->b = arg2;
6322 }
6323
6324
6325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6326   float jresult ;
6327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6328   float result;
6329
6330   arg1 = (Dali::Vector3 *)jarg1;
6331   result = (float) ((arg1)->b);
6332   jresult = result;
6333   return jresult;
6334 }
6335
6336
6337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6339
6340   arg1 = (Dali::Vector3 *)jarg1;
6341   {
6342     try {
6343       delete arg1;
6344     } catch (std::out_of_range& e) {
6345       {
6346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6347       };
6348     } catch (std::exception& e) {
6349       {
6350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6351       };
6352     } catch (...) {
6353       {
6354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6355       };
6356     }
6357   }
6358 }
6359
6360
6361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6362   void * jresult ;
6363   Dali::Vector3 *arg1 = 0 ;
6364   Dali::Vector3 *arg2 = 0 ;
6365   Dali::Vector3 result;
6366
6367   arg1 = (Dali::Vector3 *)jarg1;
6368   if (!arg1) {
6369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6370     return 0;
6371   }
6372   arg2 = (Dali::Vector3 *)jarg2;
6373   if (!arg2) {
6374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6375     return 0;
6376   }
6377   {
6378     try {
6379       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6380     } catch (std::out_of_range& e) {
6381       {
6382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (std::exception& e) {
6385       {
6386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6387       };
6388     } catch (...) {
6389       {
6390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6391       };
6392     }
6393   }
6394   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6395   return jresult;
6396 }
6397
6398
6399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6400   void * jresult ;
6401   Dali::Vector3 *arg1 = 0 ;
6402   Dali::Vector3 *arg2 = 0 ;
6403   Dali::Vector3 result;
6404
6405   arg1 = (Dali::Vector3 *)jarg1;
6406   if (!arg1) {
6407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6408     return 0;
6409   }
6410   arg2 = (Dali::Vector3 *)jarg2;
6411   if (!arg2) {
6412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6413     return 0;
6414   }
6415   {
6416     try {
6417       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6418     } catch (std::out_of_range& e) {
6419       {
6420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6421       };
6422     } catch (std::exception& e) {
6423       {
6424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6425       };
6426     } catch (...) {
6427       {
6428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6429       };
6430     }
6431   }
6432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6438   void * jresult ;
6439   Dali::Vector3 *arg1 = 0 ;
6440   float *arg2 = 0 ;
6441   float *arg3 = 0 ;
6442   float temp2 ;
6443   float temp3 ;
6444   Dali::Vector3 result;
6445
6446   arg1 = (Dali::Vector3 *)jarg1;
6447   if (!arg1) {
6448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6449     return 0;
6450   }
6451   temp2 = (float)jarg2;
6452   arg2 = &temp2;
6453   temp3 = (float)jarg3;
6454   arg3 = &temp3;
6455   {
6456     try {
6457       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (...) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6469       };
6470     }
6471   }
6472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6478   void * jresult ;
6479   Dali::Vector4 *result = 0 ;
6480
6481   {
6482     try {
6483       result = (Dali::Vector4 *)new Dali::Vector4();
6484     } catch (std::out_of_range& e) {
6485       {
6486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (std::exception& e) {
6489       {
6490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6491       };
6492     } catch (...) {
6493       {
6494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6495       };
6496     }
6497   }
6498   jresult = (void *)result;
6499   return jresult;
6500 }
6501
6502
6503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6504   void * jresult ;
6505   float arg1 ;
6506   float arg2 ;
6507   float arg3 ;
6508   float arg4 ;
6509   Dali::Vector4 *result = 0 ;
6510
6511   arg1 = (float)jarg1;
6512   arg2 = (float)jarg2;
6513   arg3 = (float)jarg3;
6514   arg4 = (float)jarg4;
6515   {
6516     try {
6517       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6518     } catch (std::out_of_range& e) {
6519       {
6520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6521       };
6522     } catch (std::exception& e) {
6523       {
6524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6525       };
6526     } catch (...) {
6527       {
6528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6529       };
6530     }
6531   }
6532   jresult = (void *)result;
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6538   void * jresult ;
6539   float *arg1 = (float *) 0 ;
6540   Dali::Vector4 *result = 0 ;
6541
6542   arg1 = jarg1;
6543   {
6544     try {
6545       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6546     } catch (std::out_of_range& e) {
6547       {
6548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6549       };
6550     } catch (std::exception& e) {
6551       {
6552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6553       };
6554     } catch (...) {
6555       {
6556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6557       };
6558     }
6559   }
6560   jresult = (void *)result;
6561
6562
6563   return jresult;
6564 }
6565
6566
6567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6568   void * jresult ;
6569   Dali::Vector2 *arg1 = 0 ;
6570   Dali::Vector4 *result = 0 ;
6571
6572   arg1 = (Dali::Vector2 *)jarg1;
6573   if (!arg1) {
6574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6575     return 0;
6576   }
6577   {
6578     try {
6579       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6580     } catch (std::out_of_range& e) {
6581       {
6582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (std::exception& e) {
6585       {
6586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (...) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6591       };
6592     }
6593   }
6594   jresult = (void *)result;
6595   return jresult;
6596 }
6597
6598
6599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6600   void * jresult ;
6601   Dali::Vector3 *arg1 = 0 ;
6602   Dali::Vector4 *result = 0 ;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   if (!arg1) {
6606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6607     return 0;
6608   }
6609   {
6610     try {
6611       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6612     } catch (std::out_of_range& e) {
6613       {
6614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (std::exception& e) {
6617       {
6618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6619       };
6620     } catch (...) {
6621       {
6622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6623       };
6624     }
6625   }
6626   jresult = (void *)result;
6627   return jresult;
6628 }
6629
6630
6631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6632   void * jresult ;
6633   Dali::Vector4 *result = 0 ;
6634
6635   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6636   jresult = (void *)result;
6637   return jresult;
6638 }
6639
6640
6641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6642   void * jresult ;
6643   Dali::Vector4 *result = 0 ;
6644
6645   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6646   jresult = (void *)result;
6647   return jresult;
6648 }
6649
6650
6651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6652   void * jresult ;
6653   Dali::Vector4 *result = 0 ;
6654
6655   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6656   jresult = (void *)result;
6657   return jresult;
6658 }
6659
6660
6661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6662   void * jresult ;
6663   Dali::Vector4 *result = 0 ;
6664
6665   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6666   jresult = (void *)result;
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6672   void * jresult ;
6673   Dali::Vector4 *result = 0 ;
6674
6675   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6676   jresult = (void *)result;
6677   return jresult;
6678 }
6679
6680
6681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6682   void * jresult ;
6683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6684   float *arg2 = (float *) 0 ;
6685   Dali::Vector4 *result = 0 ;
6686
6687   arg1 = (Dali::Vector4 *)jarg1;
6688   arg2 = jarg2;
6689   {
6690     try {
6691       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6692     } catch (std::out_of_range& e) {
6693       {
6694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (std::exception& e) {
6697       {
6698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6699       };
6700     } catch (...) {
6701       {
6702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6703       };
6704     }
6705   }
6706   jresult = (void *)result;
6707
6708
6709   return jresult;
6710 }
6711
6712
6713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6714   void * jresult ;
6715   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6716   Dali::Vector2 *arg2 = 0 ;
6717   Dali::Vector4 *result = 0 ;
6718
6719   arg1 = (Dali::Vector4 *)jarg1;
6720   arg2 = (Dali::Vector2 *)jarg2;
6721   if (!arg2) {
6722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6723     return 0;
6724   }
6725   {
6726     try {
6727       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6728     } catch (std::out_of_range& e) {
6729       {
6730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6731       };
6732     } catch (std::exception& e) {
6733       {
6734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6735       };
6736     } catch (...) {
6737       {
6738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6739       };
6740     }
6741   }
6742   jresult = (void *)result;
6743   return jresult;
6744 }
6745
6746
6747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6748   void * jresult ;
6749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6750   Dali::Vector3 *arg2 = 0 ;
6751   Dali::Vector4 *result = 0 ;
6752
6753   arg1 = (Dali::Vector4 *)jarg1;
6754   arg2 = (Dali::Vector3 *)jarg2;
6755   if (!arg2) {
6756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6757     return 0;
6758   }
6759   {
6760     try {
6761       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6762     } catch (std::out_of_range& e) {
6763       {
6764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6765       };
6766     } catch (std::exception& e) {
6767       {
6768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6769       };
6770     } catch (...) {
6771       {
6772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6773       };
6774     }
6775   }
6776   jresult = (void *)result;
6777   return jresult;
6778 }
6779
6780
6781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6782   void * jresult ;
6783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6784   Dali::Vector4 *arg2 = 0 ;
6785   Dali::Vector4 result;
6786
6787   arg1 = (Dali::Vector4 *)jarg1;
6788   arg2 = (Dali::Vector4 *)jarg2;
6789   if (!arg2) {
6790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6791     return 0;
6792   }
6793   {
6794     try {
6795       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6796     } catch (std::out_of_range& e) {
6797       {
6798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6799       };
6800     } catch (std::exception& e) {
6801       {
6802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6803       };
6804     } catch (...) {
6805       {
6806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6807       };
6808     }
6809   }
6810   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6811   return jresult;
6812 }
6813
6814
6815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6816   void * jresult ;
6817   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6818   Dali::Vector4 *arg2 = 0 ;
6819   Dali::Vector4 *result = 0 ;
6820
6821   arg1 = (Dali::Vector4 *)jarg1;
6822   arg2 = (Dali::Vector4 *)jarg2;
6823   if (!arg2) {
6824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6825     return 0;
6826   }
6827   {
6828     try {
6829       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6830     } catch (std::out_of_range& e) {
6831       {
6832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (std::exception& e) {
6835       {
6836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6837       };
6838     } catch (...) {
6839       {
6840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6841       };
6842     }
6843   }
6844   jresult = (void *)result;
6845   return jresult;
6846 }
6847
6848
6849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6850   void * jresult ;
6851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6852   Dali::Vector4 *arg2 = 0 ;
6853   Dali::Vector4 result;
6854
6855   arg1 = (Dali::Vector4 *)jarg1;
6856   arg2 = (Dali::Vector4 *)jarg2;
6857   if (!arg2) {
6858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6859     return 0;
6860   }
6861   {
6862     try {
6863       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6864     } catch (std::out_of_range& e) {
6865       {
6866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6867       };
6868     } catch (std::exception& e) {
6869       {
6870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6871       };
6872     } catch (...) {
6873       {
6874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6875       };
6876     }
6877   }
6878   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6879   return jresult;
6880 }
6881
6882
6883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6884   void * jresult ;
6885   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6886   Dali::Vector4 *arg2 = 0 ;
6887   Dali::Vector4 *result = 0 ;
6888
6889   arg1 = (Dali::Vector4 *)jarg1;
6890   arg2 = (Dali::Vector4 *)jarg2;
6891   if (!arg2) {
6892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6893     return 0;
6894   }
6895   {
6896     try {
6897       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6898     } catch (std::out_of_range& e) {
6899       {
6900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6901       };
6902     } catch (std::exception& e) {
6903       {
6904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6905       };
6906     } catch (...) {
6907       {
6908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6909       };
6910     }
6911   }
6912   jresult = (void *)result;
6913   return jresult;
6914 }
6915
6916
6917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6918   void * jresult ;
6919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6920   Dali::Vector4 *arg2 = 0 ;
6921   Dali::Vector4 result;
6922
6923   arg1 = (Dali::Vector4 *)jarg1;
6924   arg2 = (Dali::Vector4 *)jarg2;
6925   if (!arg2) {
6926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6927     return 0;
6928   }
6929   {
6930     try {
6931       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6932     } catch (std::out_of_range& e) {
6933       {
6934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6935       };
6936     } catch (std::exception& e) {
6937       {
6938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6939       };
6940     } catch (...) {
6941       {
6942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6943       };
6944     }
6945   }
6946   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6947   return jresult;
6948 }
6949
6950
6951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6952   void * jresult ;
6953   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6954   float arg2 ;
6955   Dali::Vector4 result;
6956
6957   arg1 = (Dali::Vector4 *)jarg1;
6958   arg2 = (float)jarg2;
6959   {
6960     try {
6961       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6962     } catch (std::out_of_range& e) {
6963       {
6964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6965       };
6966     } catch (std::exception& e) {
6967       {
6968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6969       };
6970     } catch (...) {
6971       {
6972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6973       };
6974     }
6975   }
6976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6977   return jresult;
6978 }
6979
6980
6981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6982   void * jresult ;
6983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6984   Dali::Vector4 *arg2 = 0 ;
6985   Dali::Vector4 *result = 0 ;
6986
6987   arg1 = (Dali::Vector4 *)jarg1;
6988   arg2 = (Dali::Vector4 *)jarg2;
6989   if (!arg2) {
6990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6991     return 0;
6992   }
6993   {
6994     try {
6995       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6996     } catch (std::out_of_range& e) {
6997       {
6998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6999       };
7000     } catch (std::exception& e) {
7001       {
7002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7003       };
7004     } catch (...) {
7005       {
7006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7007       };
7008     }
7009   }
7010   jresult = (void *)result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7016   void * jresult ;
7017   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7018   float arg2 ;
7019   Dali::Vector4 *result = 0 ;
7020
7021   arg1 = (Dali::Vector4 *)jarg1;
7022   arg2 = (float)jarg2;
7023   {
7024     try {
7025       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7026     } catch (std::out_of_range& e) {
7027       {
7028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7029       };
7030     } catch (std::exception& e) {
7031       {
7032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7033       };
7034     } catch (...) {
7035       {
7036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7037       };
7038     }
7039   }
7040   jresult = (void *)result;
7041   return jresult;
7042 }
7043
7044
7045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7046   void * jresult ;
7047   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7048   Dali::Vector4 *arg2 = 0 ;
7049   Dali::Vector4 result;
7050
7051   arg1 = (Dali::Vector4 *)jarg1;
7052   arg2 = (Dali::Vector4 *)jarg2;
7053   if (!arg2) {
7054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7055     return 0;
7056   }
7057   {
7058     try {
7059       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7060     } catch (std::out_of_range& e) {
7061       {
7062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7063       };
7064     } catch (std::exception& e) {
7065       {
7066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7067       };
7068     } catch (...) {
7069       {
7070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7071       };
7072     }
7073   }
7074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7080   void * jresult ;
7081   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7082   float arg2 ;
7083   Dali::Vector4 result;
7084
7085   arg1 = (Dali::Vector4 *)jarg1;
7086   arg2 = (float)jarg2;
7087   {
7088     try {
7089       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7090     } catch (std::out_of_range& e) {
7091       {
7092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7093       };
7094     } catch (std::exception& e) {
7095       {
7096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7097       };
7098     } catch (...) {
7099       {
7100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7101       };
7102     }
7103   }
7104   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7110   void * jresult ;
7111   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7112   Dali::Vector4 *arg2 = 0 ;
7113   Dali::Vector4 *result = 0 ;
7114
7115   arg1 = (Dali::Vector4 *)jarg1;
7116   arg2 = (Dali::Vector4 *)jarg2;
7117   if (!arg2) {
7118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7119     return 0;
7120   }
7121   {
7122     try {
7123       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7124     } catch (std::out_of_range& e) {
7125       {
7126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7127       };
7128     } catch (std::exception& e) {
7129       {
7130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7131       };
7132     } catch (...) {
7133       {
7134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7135       };
7136     }
7137   }
7138   jresult = (void *)result;
7139   return jresult;
7140 }
7141
7142
7143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7144   void * jresult ;
7145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7146   float arg2 ;
7147   Dali::Vector4 *result = 0 ;
7148
7149   arg1 = (Dali::Vector4 *)jarg1;
7150   arg2 = (float)jarg2;
7151   {
7152     try {
7153       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (...) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7165       };
7166     }
7167   }
7168   jresult = (void *)result;
7169   return jresult;
7170 }
7171
7172
7173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7174   void * jresult ;
7175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7176   Dali::Vector4 result;
7177
7178   arg1 = (Dali::Vector4 *)jarg1;
7179   {
7180     try {
7181       result = ((Dali::Vector4 const *)arg1)->operator -();
7182     } catch (std::out_of_range& e) {
7183       {
7184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7185       };
7186     } catch (std::exception& e) {
7187       {
7188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7189       };
7190     } catch (...) {
7191       {
7192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7193       };
7194     }
7195   }
7196   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7197   return jresult;
7198 }
7199
7200
7201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7202   unsigned int jresult ;
7203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7204   Dali::Vector4 *arg2 = 0 ;
7205   bool result;
7206
7207   arg1 = (Dali::Vector4 *)jarg1;
7208   arg2 = (Dali::Vector4 *)jarg2;
7209   if (!arg2) {
7210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7211     return 0;
7212   }
7213   {
7214     try {
7215       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7216     } catch (std::out_of_range& e) {
7217       {
7218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7219       };
7220     } catch (std::exception& e) {
7221       {
7222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7223       };
7224     } catch (...) {
7225       {
7226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7227       };
7228     }
7229   }
7230   jresult = result;
7231   return jresult;
7232 }
7233
7234
7235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7236   unsigned int jresult ;
7237   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7238   Dali::Vector4 *arg2 = 0 ;
7239   bool result;
7240
7241   arg1 = (Dali::Vector4 *)jarg1;
7242   arg2 = (Dali::Vector4 *)jarg2;
7243   if (!arg2) {
7244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7245     return 0;
7246   }
7247   {
7248     try {
7249       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7250     } catch (std::out_of_range& e) {
7251       {
7252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7253       };
7254     } catch (std::exception& e) {
7255       {
7256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (...) {
7259       {
7260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7261       };
7262     }
7263   }
7264   jresult = result;
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7270   float jresult ;
7271   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7272   unsigned int arg2 ;
7273   float *result = 0 ;
7274
7275   arg1 = (Dali::Vector4 *)jarg1;
7276   arg2 = (unsigned int)jarg2;
7277   {
7278     try {
7279       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7280     } catch (std::out_of_range& e) {
7281       {
7282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (std::exception& e) {
7285       {
7286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294   jresult = *result;
7295   return jresult;
7296 }
7297
7298
7299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7300   float jresult ;
7301   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7302   Dali::Vector3 *arg2 = 0 ;
7303   float result;
7304
7305   arg1 = (Dali::Vector4 *)jarg1;
7306   arg2 = (Dali::Vector3 *)jarg2;
7307   if (!arg2) {
7308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7309     return 0;
7310   }
7311   {
7312     try {
7313       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7314     } catch (std::out_of_range& e) {
7315       {
7316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (std::exception& e) {
7319       {
7320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7321       };
7322     } catch (...) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7325       };
7326     }
7327   }
7328   jresult = result;
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7334   float jresult ;
7335   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7336   Dali::Vector4 *arg2 = 0 ;
7337   float result;
7338
7339   arg1 = (Dali::Vector4 *)jarg1;
7340   arg2 = (Dali::Vector4 *)jarg2;
7341   if (!arg2) {
7342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7343     return 0;
7344   }
7345   {
7346     try {
7347       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (...) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7359       };
7360     }
7361   }
7362   jresult = result;
7363   return jresult;
7364 }
7365
7366
7367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7368   float jresult ;
7369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7370   Dali::Vector4 *arg2 = 0 ;
7371   float result;
7372
7373   arg1 = (Dali::Vector4 *)jarg1;
7374   arg2 = (Dali::Vector4 *)jarg2;
7375   if (!arg2) {
7376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7377     return 0;
7378   }
7379   {
7380     try {
7381       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7382     } catch (std::out_of_range& e) {
7383       {
7384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7385       };
7386     } catch (std::exception& e) {
7387       {
7388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7389       };
7390     } catch (...) {
7391       {
7392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7393       };
7394     }
7395   }
7396   jresult = result;
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7402   void * jresult ;
7403   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7404   Dali::Vector4 *arg2 = 0 ;
7405   Dali::Vector4 result;
7406
7407   arg1 = (Dali::Vector4 *)jarg1;
7408   arg2 = (Dali::Vector4 *)jarg2;
7409   if (!arg2) {
7410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7411     return 0;
7412   }
7413   {
7414     try {
7415       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7416     } catch (std::out_of_range& e) {
7417       {
7418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7419       };
7420     } catch (std::exception& e) {
7421       {
7422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7423       };
7424     } catch (...) {
7425       {
7426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7427       };
7428     }
7429   }
7430   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7436   float jresult ;
7437   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7438   float result;
7439
7440   arg1 = (Dali::Vector4 *)jarg1;
7441   {
7442     try {
7443       result = (float)((Dali::Vector4 const *)arg1)->Length();
7444     } catch (std::out_of_range& e) {
7445       {
7446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7447       };
7448     } catch (std::exception& e) {
7449       {
7450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (...) {
7453       {
7454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7455       };
7456     }
7457   }
7458   jresult = result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7464   float jresult ;
7465   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7466   float result;
7467
7468   arg1 = (Dali::Vector4 *)jarg1;
7469   {
7470     try {
7471       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7472     } catch (std::out_of_range& e) {
7473       {
7474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7475       };
7476     } catch (std::exception& e) {
7477       {
7478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7479       };
7480     } catch (...) {
7481       {
7482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7483       };
7484     }
7485   }
7486   jresult = result;
7487   return jresult;
7488 }
7489
7490
7491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7493
7494   arg1 = (Dali::Vector4 *)jarg1;
7495   {
7496     try {
7497       (arg1)->Normalize();
7498     } catch (std::out_of_range& e) {
7499       {
7500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7501       };
7502     } catch (std::exception& e) {
7503       {
7504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7505       };
7506     } catch (...) {
7507       {
7508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7509       };
7510     }
7511   }
7512 }
7513
7514
7515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7516   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7517   Dali::Vector4 *arg2 = 0 ;
7518   Dali::Vector4 *arg3 = 0 ;
7519
7520   arg1 = (Dali::Vector4 *)jarg1;
7521   arg2 = (Dali::Vector4 *)jarg2;
7522   if (!arg2) {
7523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7524     return ;
7525   }
7526   arg3 = (Dali::Vector4 *)jarg3;
7527   if (!arg3) {
7528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7529     return ;
7530   }
7531   {
7532     try {
7533       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7534     } catch (std::out_of_range& e) {
7535       {
7536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7537       };
7538     } catch (std::exception& e) {
7539       {
7540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7541       };
7542     } catch (...) {
7543       {
7544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7545       };
7546     }
7547   }
7548 }
7549
7550
7551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7552   void * jresult ;
7553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7554   float *result = 0 ;
7555
7556   arg1 = (Dali::Vector4 *)jarg1;
7557   {
7558     try {
7559       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7560     } catch (std::out_of_range& e) {
7561       {
7562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7563       };
7564     } catch (std::exception& e) {
7565       {
7566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7567       };
7568     } catch (...) {
7569       {
7570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7571       };
7572     }
7573   }
7574   jresult = (void *)result;
7575   return jresult;
7576 }
7577
7578
7579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7580   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7581   float arg2 ;
7582
7583   arg1 = (Dali::Vector4 *)jarg1;
7584   arg2 = (float)jarg2;
7585   if (arg1) (arg1)->x = arg2;
7586 }
7587
7588
7589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7590   float jresult ;
7591   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7592   float result;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   result = (float) ((arg1)->x);
7596   jresult = result;
7597   return jresult;
7598 }
7599
7600
7601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7603   float arg2 ;
7604
7605   arg1 = (Dali::Vector4 *)jarg1;
7606   arg2 = (float)jarg2;
7607   if (arg1) (arg1)->r = arg2;
7608 }
7609
7610
7611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7612   float jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   float result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   result = (float) ((arg1)->r);
7618   jresult = result;
7619   return jresult;
7620 }
7621
7622
7623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7624   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7625   float arg2 ;
7626
7627   arg1 = (Dali::Vector4 *)jarg1;
7628   arg2 = (float)jarg2;
7629   if (arg1) (arg1)->s = arg2;
7630 }
7631
7632
7633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7634   float jresult ;
7635   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7636   float result;
7637
7638   arg1 = (Dali::Vector4 *)jarg1;
7639   result = (float) ((arg1)->s);
7640   jresult = result;
7641   return jresult;
7642 }
7643
7644
7645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   float arg2 ;
7648
7649   arg1 = (Dali::Vector4 *)jarg1;
7650   arg2 = (float)jarg2;
7651   if (arg1) (arg1)->y = arg2;
7652 }
7653
7654
7655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7656   float jresult ;
7657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7658   float result;
7659
7660   arg1 = (Dali::Vector4 *)jarg1;
7661   result = (float) ((arg1)->y);
7662   jresult = result;
7663   return jresult;
7664 }
7665
7666
7667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7669   float arg2 ;
7670
7671   arg1 = (Dali::Vector4 *)jarg1;
7672   arg2 = (float)jarg2;
7673   if (arg1) (arg1)->g = arg2;
7674 }
7675
7676
7677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7678   float jresult ;
7679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7680   float result;
7681
7682   arg1 = (Dali::Vector4 *)jarg1;
7683   result = (float) ((arg1)->g);
7684   jresult = result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   float arg2 ;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   arg2 = (float)jarg2;
7695   if (arg1) (arg1)->t = arg2;
7696 }
7697
7698
7699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7700   float jresult ;
7701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7702   float result;
7703
7704   arg1 = (Dali::Vector4 *)jarg1;
7705   result = (float) ((arg1)->t);
7706   jresult = result;
7707   return jresult;
7708 }
7709
7710
7711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7713   float arg2 ;
7714
7715   arg1 = (Dali::Vector4 *)jarg1;
7716   arg2 = (float)jarg2;
7717   if (arg1) (arg1)->z = arg2;
7718 }
7719
7720
7721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7722   float jresult ;
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   float result;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   result = (float) ((arg1)->z);
7728   jresult = result;
7729   return jresult;
7730 }
7731
7732
7733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7735   float arg2 ;
7736
7737   arg1 = (Dali::Vector4 *)jarg1;
7738   arg2 = (float)jarg2;
7739   if (arg1) (arg1)->b = arg2;
7740 }
7741
7742
7743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7744   float jresult ;
7745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7746   float result;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   result = (float) ((arg1)->b);
7750   jresult = result;
7751   return jresult;
7752 }
7753
7754
7755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7757   float arg2 ;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   arg2 = (float)jarg2;
7761   if (arg1) (arg1)->p = arg2;
7762 }
7763
7764
7765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7766   float jresult ;
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   float result;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   result = (float) ((arg1)->p);
7772   jresult = result;
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7779   float arg2 ;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   arg2 = (float)jarg2;
7783   if (arg1) (arg1)->w = arg2;
7784 }
7785
7786
7787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7788   float jresult ;
7789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7790   float result;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   result = (float) ((arg1)->w);
7794   jresult = result;
7795   return jresult;
7796 }
7797
7798
7799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7801   float arg2 ;
7802
7803   arg1 = (Dali::Vector4 *)jarg1;
7804   arg2 = (float)jarg2;
7805   if (arg1) (arg1)->a = arg2;
7806 }
7807
7808
7809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7810   float jresult ;
7811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7812   float result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   result = (float) ((arg1)->a);
7816   jresult = result;
7817   return jresult;
7818 }
7819
7820
7821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7822   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7823   float arg2 ;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   arg2 = (float)jarg2;
7827   if (arg1) (arg1)->q = arg2;
7828 }
7829
7830
7831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7832   float jresult ;
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float result;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   result = (float) ((arg1)->q);
7838   jresult = result;
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   {
7848     try {
7849       delete arg1;
7850     } catch (std::out_of_range& e) {
7851       {
7852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7853       };
7854     } catch (std::exception& e) {
7855       {
7856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7857       };
7858     } catch (...) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7861       };
7862     }
7863   }
7864 }
7865
7866
7867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7868   void * jresult ;
7869   Dali::Vector4 *arg1 = 0 ;
7870   Dali::Vector4 *arg2 = 0 ;
7871   Dali::Vector4 result;
7872
7873   arg1 = (Dali::Vector4 *)jarg1;
7874   if (!arg1) {
7875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7876     return 0;
7877   }
7878   arg2 = (Dali::Vector4 *)jarg2;
7879   if (!arg2) {
7880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7881     return 0;
7882   }
7883   {
7884     try {
7885       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7886     } catch (std::out_of_range& e) {
7887       {
7888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7889       };
7890     } catch (std::exception& e) {
7891       {
7892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (...) {
7895       {
7896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7897       };
7898     }
7899   }
7900   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7901   return jresult;
7902 }
7903
7904
7905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7906   void * jresult ;
7907   Dali::Vector4 *arg1 = 0 ;
7908   Dali::Vector4 *arg2 = 0 ;
7909   Dali::Vector4 result;
7910
7911   arg1 = (Dali::Vector4 *)jarg1;
7912   if (!arg1) {
7913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7914     return 0;
7915   }
7916   arg2 = (Dali::Vector4 *)jarg2;
7917   if (!arg2) {
7918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7919     return 0;
7920   }
7921   {
7922     try {
7923       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7924     } catch (std::out_of_range& e) {
7925       {
7926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (std::exception& e) {
7929       {
7930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7931       };
7932     } catch (...) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7935       };
7936     }
7937   }
7938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = 0 ;
7946   float *arg2 = 0 ;
7947   float *arg3 = 0 ;
7948   float temp2 ;
7949   float temp3 ;
7950   Dali::Vector4 result;
7951
7952   arg1 = (Dali::Vector4 *)jarg1;
7953   if (!arg1) {
7954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7955     return 0;
7956   }
7957   temp2 = (float)jarg2;
7958   arg2 = &temp2;
7959   temp3 = (float)jarg3;
7960   arg3 = &temp3;
7961   {
7962     try {
7963       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (...) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7975       };
7976     }
7977   }
7978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7984   void * jresult ;
7985   Dali::Uint16Pair *result = 0 ;
7986
7987   {
7988     try {
7989       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7990     } catch (std::out_of_range& e) {
7991       {
7992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (std::exception& e) {
7995       {
7996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (...) {
7999       {
8000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8001       };
8002     }
8003   }
8004   jresult = (void *)result;
8005   return jresult;
8006 }
8007
8008
8009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8010   void * jresult ;
8011   uint32_t arg1 ;
8012   uint32_t arg2 ;
8013   Dali::Uint16Pair *result = 0 ;
8014
8015   arg1 = (uint32_t)jarg1;
8016   arg2 = (uint32_t)jarg2;
8017   {
8018     try {
8019       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8020     } catch (std::out_of_range& e) {
8021       {
8022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8023       };
8024     } catch (std::exception& e) {
8025       {
8026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (...) {
8029       {
8030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8031       };
8032     }
8033   }
8034   jresult = (void *)result;
8035   return jresult;
8036 }
8037
8038
8039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8040   void * jresult ;
8041   Dali::Uint16Pair *arg1 = 0 ;
8042   Dali::Uint16Pair *result = 0 ;
8043
8044   arg1 = (Dali::Uint16Pair *)jarg1;
8045   if (!arg1) {
8046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8047     return 0;
8048   }
8049   {
8050     try {
8051       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8052     } catch (std::out_of_range& e) {
8053       {
8054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8055       };
8056     } catch (std::exception& e) {
8057       {
8058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8059       };
8060     } catch (...) {
8061       {
8062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8063       };
8064     }
8065   }
8066   jresult = (void *)result;
8067   return jresult;
8068 }
8069
8070
8071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8072   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8073   uint16_t arg2 ;
8074
8075   arg1 = (Dali::Uint16Pair *)jarg1;
8076   arg2 = (uint16_t)jarg2;
8077   {
8078     try {
8079       (arg1)->SetWidth(arg2);
8080     } catch (std::out_of_range& e) {
8081       {
8082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8083       };
8084     } catch (std::exception& e) {
8085       {
8086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8087       };
8088     } catch (...) {
8089       {
8090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8091       };
8092     }
8093   }
8094 }
8095
8096
8097 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8098   unsigned short jresult ;
8099   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8100   uint16_t result;
8101
8102   arg1 = (Dali::Uint16Pair *)jarg1;
8103   {
8104     try {
8105       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8106     } catch (std::out_of_range& e) {
8107       {
8108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8109       };
8110     } catch (std::exception& e) {
8111       {
8112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (...) {
8115       {
8116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8117       };
8118     }
8119   }
8120   jresult = result;
8121   return jresult;
8122 }
8123
8124
8125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8127   uint16_t arg2 ;
8128
8129   arg1 = (Dali::Uint16Pair *)jarg1;
8130   arg2 = (uint16_t)jarg2;
8131   {
8132     try {
8133       (arg1)->SetHeight(arg2);
8134     } catch (std::out_of_range& e) {
8135       {
8136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8137       };
8138     } catch (std::exception& e) {
8139       {
8140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8141       };
8142     } catch (...) {
8143       {
8144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8145       };
8146     }
8147   }
8148 }
8149
8150
8151 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8152   unsigned short jresult ;
8153   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8154   uint16_t result;
8155
8156   arg1 = (Dali::Uint16Pair *)jarg1;
8157   {
8158     try {
8159       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8160     } catch (std::out_of_range& e) {
8161       {
8162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8163       };
8164     } catch (std::exception& e) {
8165       {
8166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8167       };
8168     } catch (...) {
8169       {
8170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8171       };
8172     }
8173   }
8174   jresult = result;
8175   return jresult;
8176 }
8177
8178
8179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8180   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8181   uint16_t arg2 ;
8182
8183   arg1 = (Dali::Uint16Pair *)jarg1;
8184   arg2 = (uint16_t)jarg2;
8185   {
8186     try {
8187       (arg1)->SetX(arg2);
8188     } catch (std::out_of_range& e) {
8189       {
8190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8191       };
8192     } catch (std::exception& e) {
8193       {
8194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8199       };
8200     }
8201   }
8202 }
8203
8204
8205 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8206   unsigned short jresult ;
8207   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8208   uint16_t result;
8209
8210   arg1 = (Dali::Uint16Pair *)jarg1;
8211   {
8212     try {
8213       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8214     } catch (std::out_of_range& e) {
8215       {
8216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8217       };
8218     } catch (std::exception& e) {
8219       {
8220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8225       };
8226     }
8227   }
8228   jresult = result;
8229   return jresult;
8230 }
8231
8232
8233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8234   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8235   uint16_t arg2 ;
8236
8237   arg1 = (Dali::Uint16Pair *)jarg1;
8238   arg2 = (uint16_t)jarg2;
8239   {
8240     try {
8241       (arg1)->SetY(arg2);
8242     } catch (std::out_of_range& e) {
8243       {
8244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8245       };
8246     } catch (std::exception& e) {
8247       {
8248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8249       };
8250     } catch (...) {
8251       {
8252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8253       };
8254     }
8255   }
8256 }
8257
8258
8259 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8260   unsigned short jresult ;
8261   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8262   uint16_t result;
8263
8264   arg1 = (Dali::Uint16Pair *)jarg1;
8265   {
8266     try {
8267       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8268     } catch (std::out_of_range& e) {
8269       {
8270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8271       };
8272     } catch (std::exception& e) {
8273       {
8274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8275       };
8276     } catch (...) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8279       };
8280     }
8281   }
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8288   void * jresult ;
8289   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8290   Dali::Uint16Pair *arg2 = 0 ;
8291   Dali::Uint16Pair *result = 0 ;
8292
8293   arg1 = (Dali::Uint16Pair *)jarg1;
8294   arg2 = (Dali::Uint16Pair *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (...) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8313       };
8314     }
8315   }
8316   jresult = (void *)result;
8317   return jresult;
8318 }
8319
8320
8321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8322   unsigned int jresult ;
8323   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8324   Dali::Uint16Pair *arg2 = 0 ;
8325   bool result;
8326
8327   arg1 = (Dali::Uint16Pair *)jarg1;
8328   arg2 = (Dali::Uint16Pair *)jarg2;
8329   if (!arg2) {
8330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8331     return 0;
8332   }
8333   {
8334     try {
8335       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8336     } catch (std::out_of_range& e) {
8337       {
8338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8339       };
8340     } catch (std::exception& e) {
8341       {
8342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (...) {
8345       {
8346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8347       };
8348     }
8349   }
8350   jresult = result;
8351   return jresult;
8352 }
8353
8354
8355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8356   unsigned int jresult ;
8357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8358   Dali::Uint16Pair *arg2 = 0 ;
8359   bool result;
8360
8361   arg1 = (Dali::Uint16Pair *)jarg1;
8362   arg2 = (Dali::Uint16Pair *)jarg2;
8363   if (!arg2) {
8364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8365     return 0;
8366   }
8367   {
8368     try {
8369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8370     } catch (std::out_of_range& e) {
8371       {
8372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (std::exception& e) {
8375       {
8376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (...) {
8379       {
8380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8381       };
8382     }
8383   }
8384   jresult = result;
8385   return jresult;
8386 }
8387
8388
8389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8390   unsigned int jresult ;
8391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8392   Dali::Uint16Pair *arg2 = 0 ;
8393   bool result;
8394
8395   arg1 = (Dali::Uint16Pair *)jarg1;
8396   arg2 = (Dali::Uint16Pair *)jarg2;
8397   if (!arg2) {
8398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8399     return 0;
8400   }
8401   {
8402     try {
8403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8404     } catch (std::out_of_range& e) {
8405       {
8406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8407       };
8408     } catch (std::exception& e) {
8409       {
8410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8411       };
8412     } catch (...) {
8413       {
8414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8415       };
8416     }
8417   }
8418   jresult = result;
8419   return jresult;
8420 }
8421
8422
8423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8424   unsigned int jresult ;
8425   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8426   Dali::Uint16Pair *arg2 = 0 ;
8427   bool result;
8428
8429   arg1 = (Dali::Uint16Pair *)jarg1;
8430   arg2 = (Dali::Uint16Pair *)jarg2;
8431   if (!arg2) {
8432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8433     return 0;
8434   }
8435   {
8436     try {
8437       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8449       };
8450     }
8451   }
8452   jresult = result;
8453   return jresult;
8454 }
8455
8456
8457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8458   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8459
8460   arg1 = (Dali::Uint16Pair *)jarg1;
8461   {
8462     try {
8463       delete arg1;
8464     } catch (std::out_of_range& e) {
8465       {
8466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8467       };
8468     } catch (std::exception& e) {
8469       {
8470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8471       };
8472     } catch (...) {
8473       {
8474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8475       };
8476     }
8477   }
8478 }
8479
8480
8481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8482   void * jresult ;
8483   Dali::Degree *result = 0 ;
8484
8485   {
8486     try {
8487       result = (Dali::Degree *)new Dali::Degree();
8488     } catch (std::out_of_range& e) {
8489       {
8490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8491       };
8492     } catch (std::exception& e) {
8493       {
8494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8495       };
8496     } catch (...) {
8497       {
8498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8499       };
8500     }
8501   }
8502   jresult = (void *)result;
8503   return jresult;
8504 }
8505
8506
8507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8508   void * jresult ;
8509   float arg1 ;
8510   Dali::Degree *result = 0 ;
8511
8512   arg1 = (float)jarg1;
8513   {
8514     try {
8515       result = (Dali::Degree *)new Dali::Degree(arg1);
8516     } catch (std::out_of_range& e) {
8517       {
8518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (std::exception& e) {
8521       {
8522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530   jresult = (void *)result;
8531   return jresult;
8532 }
8533
8534
8535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8536   void * jresult ;
8537   Dali::Radian arg1 ;
8538   Dali::Radian *argp1 ;
8539   Dali::Degree *result = 0 ;
8540
8541   argp1 = (Dali::Radian *)jarg1;
8542   if (!argp1) {
8543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8544     return 0;
8545   }
8546   arg1 = *argp1;
8547   {
8548     try {
8549       result = (Dali::Degree *)new Dali::Degree(arg1);
8550     } catch (std::out_of_range& e) {
8551       {
8552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8553       };
8554     } catch (std::exception& e) {
8555       {
8556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8557       };
8558     } catch (...) {
8559       {
8560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8561       };
8562     }
8563   }
8564   jresult = (void *)result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8570   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8571   float arg2 ;
8572
8573   arg1 = (Dali::Degree *)jarg1;
8574   arg2 = (float)jarg2;
8575   if (arg1) (arg1)->degree = arg2;
8576 }
8577
8578
8579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8580   float jresult ;
8581   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8582   float result;
8583
8584   arg1 = (Dali::Degree *)jarg1;
8585   result = (float) ((arg1)->degree);
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8592   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8593
8594   arg1 = (Dali::Degree *)jarg1;
8595   {
8596     try {
8597       delete arg1;
8598     } catch (std::out_of_range& e) {
8599       {
8600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8601       };
8602     } catch (std::exception& e) {
8603       {
8604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8605       };
8606     } catch (...) {
8607       {
8608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8609       };
8610     }
8611   }
8612 }
8613
8614
8615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8616   void * jresult ;
8617   Dali::Radian *result = 0 ;
8618
8619   result = (Dali::Radian *)&Dali::ANGLE_360;
8620   jresult = (void *)result;
8621   return jresult;
8622 }
8623
8624
8625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8626   void * jresult ;
8627   Dali::Radian *result = 0 ;
8628
8629   result = (Dali::Radian *)&Dali::ANGLE_315;
8630   jresult = (void *)result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8636   void * jresult ;
8637   Dali::Radian *result = 0 ;
8638
8639   result = (Dali::Radian *)&Dali::ANGLE_270;
8640   jresult = (void *)result;
8641   return jresult;
8642 }
8643
8644
8645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8646   void * jresult ;
8647   Dali::Radian *result = 0 ;
8648
8649   result = (Dali::Radian *)&Dali::ANGLE_225;
8650   jresult = (void *)result;
8651   return jresult;
8652 }
8653
8654
8655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8656   void * jresult ;
8657   Dali::Radian *result = 0 ;
8658
8659   result = (Dali::Radian *)&Dali::ANGLE_180;
8660   jresult = (void *)result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8666   void * jresult ;
8667   Dali::Radian *result = 0 ;
8668
8669   result = (Dali::Radian *)&Dali::ANGLE_135;
8670   jresult = (void *)result;
8671   return jresult;
8672 }
8673
8674
8675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8676   void * jresult ;
8677   Dali::Radian *result = 0 ;
8678
8679   result = (Dali::Radian *)&Dali::ANGLE_120;
8680   jresult = (void *)result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8686   void * jresult ;
8687   Dali::Radian *result = 0 ;
8688
8689   result = (Dali::Radian *)&Dali::ANGLE_90;
8690   jresult = (void *)result;
8691   return jresult;
8692 }
8693
8694
8695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8696   void * jresult ;
8697   Dali::Radian *result = 0 ;
8698
8699   result = (Dali::Radian *)&Dali::ANGLE_60;
8700   jresult = (void *)result;
8701   return jresult;
8702 }
8703
8704
8705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8706   void * jresult ;
8707   Dali::Radian *result = 0 ;
8708
8709   result = (Dali::Radian *)&Dali::ANGLE_45;
8710   jresult = (void *)result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_30;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_0;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8736   unsigned int jresult ;
8737   Dali::Degree *arg1 = 0 ;
8738   Dali::Degree *arg2 = 0 ;
8739   bool result;
8740
8741   arg1 = (Dali::Degree *)jarg1;
8742   if (!arg1) {
8743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8744     return 0;
8745   }
8746   arg2 = (Dali::Degree *)jarg2;
8747   if (!arg2) {
8748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8749     return 0;
8750   }
8751   {
8752     try {
8753       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8754     } catch (std::out_of_range& e) {
8755       {
8756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8757       };
8758     } catch (std::exception& e) {
8759       {
8760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8761       };
8762     } catch (...) {
8763       {
8764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8765       };
8766     }
8767   }
8768   jresult = result;
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8774   unsigned int jresult ;
8775   Dali::Degree *arg1 = 0 ;
8776   Dali::Degree *arg2 = 0 ;
8777   bool result;
8778
8779   arg1 = (Dali::Degree *)jarg1;
8780   if (!arg1) {
8781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8782     return 0;
8783   }
8784   arg2 = (Dali::Degree *)jarg2;
8785   if (!arg2) {
8786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8787     return 0;
8788   }
8789   {
8790     try {
8791       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8792     } catch (std::out_of_range& e) {
8793       {
8794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8795       };
8796     } catch (std::exception& e) {
8797       {
8798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8799       };
8800     } catch (...) {
8801       {
8802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8803       };
8804     }
8805   }
8806   jresult = result;
8807   return jresult;
8808 }
8809
8810
8811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8812   void * jresult ;
8813   Dali::Degree arg1 ;
8814   float arg2 ;
8815   float arg3 ;
8816   Dali::Degree *argp1 ;
8817   Dali::Degree result;
8818
8819   argp1 = (Dali::Degree *)jarg1;
8820   if (!argp1) {
8821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8822     return 0;
8823   }
8824   arg1 = *argp1;
8825   arg2 = (float)jarg2;
8826   arg3 = (float)jarg3;
8827   {
8828     try {
8829       result = Dali::Clamp(arg1,arg2,arg3);
8830     } catch (std::out_of_range& e) {
8831       {
8832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8833       };
8834     } catch (std::exception& e) {
8835       {
8836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8837       };
8838     } catch (...) {
8839       {
8840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8841       };
8842     }
8843   }
8844   jresult = new Dali::Degree((const Dali::Degree &)result);
8845   return jresult;
8846 }
8847
8848
8849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8850   void * jresult ;
8851   Dali::Radian *result = 0 ;
8852
8853   {
8854     try {
8855       result = (Dali::Radian *)new Dali::Radian();
8856     } catch (std::out_of_range& e) {
8857       {
8858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8859       };
8860     } catch (std::exception& e) {
8861       {
8862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8863       };
8864     } catch (...) {
8865       {
8866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8867       };
8868     }
8869   }
8870   jresult = (void *)result;
8871   return jresult;
8872 }
8873
8874
8875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8876   void * jresult ;
8877   float arg1 ;
8878   Dali::Radian *result = 0 ;
8879
8880   arg1 = (float)jarg1;
8881   {
8882     try {
8883       result = (Dali::Radian *)new Dali::Radian(arg1);
8884     } catch (std::out_of_range& e) {
8885       {
8886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8887       };
8888     } catch (std::exception& e) {
8889       {
8890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (...) {
8893       {
8894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8895       };
8896     }
8897   }
8898   jresult = (void *)result;
8899   return jresult;
8900 }
8901
8902
8903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8904   void * jresult ;
8905   Dali::Degree arg1 ;
8906   Dali::Degree *argp1 ;
8907   Dali::Radian *result = 0 ;
8908
8909   argp1 = (Dali::Degree *)jarg1;
8910   if (!argp1) {
8911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8912     return 0;
8913   }
8914   arg1 = *argp1;
8915   {
8916     try {
8917       result = (Dali::Radian *)new Dali::Radian(arg1);
8918     } catch (std::out_of_range& e) {
8919       {
8920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (std::exception& e) {
8923       {
8924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8925       };
8926     } catch (...) {
8927       {
8928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8929       };
8930     }
8931   }
8932   jresult = (void *)result;
8933   return jresult;
8934 }
8935
8936
8937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8938   void * jresult ;
8939   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8940   float arg2 ;
8941   Dali::Radian *result = 0 ;
8942
8943   arg1 = (Dali::Radian *)jarg1;
8944   arg2 = (float)jarg2;
8945   {
8946     try {
8947       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8948     } catch (std::out_of_range& e) {
8949       {
8950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8951       };
8952     } catch (std::exception& e) {
8953       {
8954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8955       };
8956     } catch (...) {
8957       {
8958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8959       };
8960     }
8961   }
8962   jresult = (void *)result;
8963   return jresult;
8964 }
8965
8966
8967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8968   void * jresult ;
8969   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8970   Dali::Degree arg2 ;
8971   Dali::Degree *argp2 ;
8972   Dali::Radian *result = 0 ;
8973
8974   arg1 = (Dali::Radian *)jarg1;
8975   argp2 = (Dali::Degree *)jarg2;
8976   if (!argp2) {
8977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8978     return 0;
8979   }
8980   arg2 = *argp2;
8981   {
8982     try {
8983       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8984     } catch (std::out_of_range& e) {
8985       {
8986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8987       };
8988     } catch (std::exception& e) {
8989       {
8990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8991       };
8992     } catch (...) {
8993       {
8994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8995       };
8996     }
8997   }
8998   jresult = (void *)result;
8999   return jresult;
9000 }
9001
9002
9003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9004   float jresult ;
9005   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9006   float result;
9007
9008   arg1 = (Dali::Radian *)jarg1;
9009   {
9010     try {
9011       result = (float)((Dali::Radian const *)arg1)->operator float();
9012     } catch (std::out_of_range& e) {
9013       {
9014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9015       };
9016     } catch (std::exception& e) {
9017       {
9018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9019       };
9020     } catch (...) {
9021       {
9022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9023       };
9024     }
9025   }
9026   jresult = result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9032   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9033   float arg2 ;
9034
9035   arg1 = (Dali::Radian *)jarg1;
9036   arg2 = (float)jarg2;
9037   if (arg1) (arg1)->radian = arg2;
9038 }
9039
9040
9041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9042   float jresult ;
9043   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9044   float result;
9045
9046   arg1 = (Dali::Radian *)jarg1;
9047   result = (float) ((arg1)->radian);
9048   jresult = result;
9049   return jresult;
9050 }
9051
9052
9053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9054   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9055
9056   arg1 = (Dali::Radian *)jarg1;
9057   {
9058     try {
9059       delete arg1;
9060     } catch (std::out_of_range& e) {
9061       {
9062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9063       };
9064     } catch (std::exception& e) {
9065       {
9066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9071       };
9072     }
9073   }
9074 }
9075
9076
9077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9078   unsigned int jresult ;
9079   Dali::Radian arg1 ;
9080   Dali::Radian arg2 ;
9081   Dali::Radian *argp1 ;
9082   Dali::Radian *argp2 ;
9083   bool result;
9084
9085   argp1 = (Dali::Radian *)jarg1;
9086   if (!argp1) {
9087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9088     return 0;
9089   }
9090   arg1 = *argp1;
9091   argp2 = (Dali::Radian *)jarg2;
9092   if (!argp2) {
9093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9094     return 0;
9095   }
9096   arg2 = *argp2;
9097   {
9098     try {
9099       result = (bool)Dali::operator ==(arg1,arg2);
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (...) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9111       };
9112     }
9113   }
9114   jresult = result;
9115   return jresult;
9116 }
9117
9118
9119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9120   unsigned int jresult ;
9121   Dali::Radian arg1 ;
9122   Dali::Radian arg2 ;
9123   Dali::Radian *argp1 ;
9124   Dali::Radian *argp2 ;
9125   bool result;
9126
9127   argp1 = (Dali::Radian *)jarg1;
9128   if (!argp1) {
9129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9130     return 0;
9131   }
9132   arg1 = *argp1;
9133   argp2 = (Dali::Radian *)jarg2;
9134   if (!argp2) {
9135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9136     return 0;
9137   }
9138   arg2 = *argp2;
9139   {
9140     try {
9141       result = (bool)Dali::operator !=(arg1,arg2);
9142     } catch (std::out_of_range& e) {
9143       {
9144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9145       };
9146     } catch (std::exception& e) {
9147       {
9148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9149       };
9150     } catch (...) {
9151       {
9152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9153       };
9154     }
9155   }
9156   jresult = result;
9157   return jresult;
9158 }
9159
9160
9161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9162   unsigned int jresult ;
9163   Dali::Radian arg1 ;
9164   Dali::Degree arg2 ;
9165   Dali::Radian *argp1 ;
9166   Dali::Degree *argp2 ;
9167   bool result;
9168
9169   argp1 = (Dali::Radian *)jarg1;
9170   if (!argp1) {
9171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9172     return 0;
9173   }
9174   arg1 = *argp1;
9175   argp2 = (Dali::Degree *)jarg2;
9176   if (!argp2) {
9177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9178     return 0;
9179   }
9180   arg2 = *argp2;
9181   {
9182     try {
9183       result = (bool)Dali::operator ==(arg1,arg2);
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9191       };
9192     } catch (...) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9195       };
9196     }
9197   }
9198   jresult = result;
9199   return jresult;
9200 }
9201
9202
9203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9204   unsigned int jresult ;
9205   Dali::Radian arg1 ;
9206   Dali::Degree arg2 ;
9207   Dali::Radian *argp1 ;
9208   Dali::Degree *argp2 ;
9209   bool result;
9210
9211   argp1 = (Dali::Radian *)jarg1;
9212   if (!argp1) {
9213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9214     return 0;
9215   }
9216   arg1 = *argp1;
9217   argp2 = (Dali::Degree *)jarg2;
9218   if (!argp2) {
9219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9220     return 0;
9221   }
9222   arg2 = *argp2;
9223   {
9224     try {
9225       result = (bool)Dali::operator !=(arg1,arg2);
9226     } catch (std::out_of_range& e) {
9227       {
9228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (std::exception& e) {
9231       {
9232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (...) {
9235       {
9236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9237       };
9238     }
9239   }
9240   jresult = result;
9241   return jresult;
9242 }
9243
9244
9245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9246   unsigned int jresult ;
9247   Dali::Degree arg1 ;
9248   Dali::Radian arg2 ;
9249   Dali::Degree *argp1 ;
9250   Dali::Radian *argp2 ;
9251   bool result;
9252
9253   argp1 = (Dali::Degree *)jarg1;
9254   if (!argp1) {
9255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9256     return 0;
9257   }
9258   arg1 = *argp1;
9259   argp2 = (Dali::Radian *)jarg2;
9260   if (!argp2) {
9261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9262     return 0;
9263   }
9264   arg2 = *argp2;
9265   {
9266     try {
9267       result = (bool)Dali::operator ==(arg1,arg2);
9268     } catch (std::out_of_range& e) {
9269       {
9270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9271       };
9272     } catch (std::exception& e) {
9273       {
9274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9279       };
9280     }
9281   }
9282   jresult = result;
9283   return jresult;
9284 }
9285
9286
9287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9288   unsigned int jresult ;
9289   Dali::Degree arg1 ;
9290   Dali::Radian arg2 ;
9291   Dali::Degree *argp1 ;
9292   Dali::Radian *argp2 ;
9293   bool result;
9294
9295   argp1 = (Dali::Degree *)jarg1;
9296   if (!argp1) {
9297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9298     return 0;
9299   }
9300   arg1 = *argp1;
9301   argp2 = (Dali::Radian *)jarg2;
9302   if (!argp2) {
9303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9304     return 0;
9305   }
9306   arg2 = *argp2;
9307   {
9308     try {
9309       result = (bool)Dali::operator !=(arg1,arg2);
9310     } catch (std::out_of_range& e) {
9311       {
9312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9313       };
9314     } catch (std::exception& e) {
9315       {
9316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9317       };
9318     } catch (...) {
9319       {
9320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9321       };
9322     }
9323   }
9324   jresult = result;
9325   return jresult;
9326 }
9327
9328
9329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9330   unsigned int jresult ;
9331   Dali::Radian arg1 ;
9332   Dali::Radian arg2 ;
9333   Dali::Radian *argp1 ;
9334   Dali::Radian *argp2 ;
9335   bool result;
9336
9337   argp1 = (Dali::Radian *)jarg1;
9338   if (!argp1) {
9339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9340     return 0;
9341   }
9342   arg1 = *argp1;
9343   argp2 = (Dali::Radian *)jarg2;
9344   if (!argp2) {
9345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9346     return 0;
9347   }
9348   arg2 = *argp2;
9349   {
9350     try {
9351       result = (bool)Dali::operator >(arg1,arg2);
9352     } catch (std::out_of_range& e) {
9353       {
9354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (std::exception& e) {
9357       {
9358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9359       };
9360     } catch (...) {
9361       {
9362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9363       };
9364     }
9365   }
9366   jresult = result;
9367   return jresult;
9368 }
9369
9370
9371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9372   unsigned int jresult ;
9373   Dali::Radian arg1 ;
9374   Dali::Degree arg2 ;
9375   Dali::Radian *argp1 ;
9376   Dali::Degree *argp2 ;
9377   bool result;
9378
9379   argp1 = (Dali::Radian *)jarg1;
9380   if (!argp1) {
9381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9382     return 0;
9383   }
9384   arg1 = *argp1;
9385   argp2 = (Dali::Degree *)jarg2;
9386   if (!argp2) {
9387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9388     return 0;
9389   }
9390   arg2 = *argp2;
9391   {
9392     try {
9393       result = (bool)Dali::operator >(arg1,arg2);
9394     } catch (std::out_of_range& e) {
9395       {
9396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9397       };
9398     } catch (std::exception& e) {
9399       {
9400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9401       };
9402     } catch (...) {
9403       {
9404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9405       };
9406     }
9407   }
9408   jresult = result;
9409   return jresult;
9410 }
9411
9412
9413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9414   unsigned int jresult ;
9415   Dali::Degree arg1 ;
9416   Dali::Radian arg2 ;
9417   Dali::Degree *argp1 ;
9418   Dali::Radian *argp2 ;
9419   bool result;
9420
9421   argp1 = (Dali::Degree *)jarg1;
9422   if (!argp1) {
9423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9424     return 0;
9425   }
9426   arg1 = *argp1;
9427   argp2 = (Dali::Radian *)jarg2;
9428   if (!argp2) {
9429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9430     return 0;
9431   }
9432   arg2 = *argp2;
9433   {
9434     try {
9435       result = (bool)Dali::operator >(arg1,arg2);
9436     } catch (std::out_of_range& e) {
9437       {
9438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9439       };
9440     } catch (std::exception& e) {
9441       {
9442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9443       };
9444     } catch (...) {
9445       {
9446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9447       };
9448     }
9449   }
9450   jresult = result;
9451   return jresult;
9452 }
9453
9454
9455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9456   unsigned int jresult ;
9457   Dali::Radian arg1 ;
9458   Dali::Radian arg2 ;
9459   Dali::Radian *argp1 ;
9460   Dali::Radian *argp2 ;
9461   bool result;
9462
9463   argp1 = (Dali::Radian *)jarg1;
9464   if (!argp1) {
9465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9466     return 0;
9467   }
9468   arg1 = *argp1;
9469   argp2 = (Dali::Radian *)jarg2;
9470   if (!argp2) {
9471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9472     return 0;
9473   }
9474   arg2 = *argp2;
9475   {
9476     try {
9477       result = (bool)Dali::operator <(arg1,arg2);
9478     } catch (std::out_of_range& e) {
9479       {
9480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (std::exception& e) {
9483       {
9484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9489       };
9490     }
9491   }
9492   jresult = result;
9493   return jresult;
9494 }
9495
9496
9497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9498   unsigned int jresult ;
9499   Dali::Radian arg1 ;
9500   Dali::Degree arg2 ;
9501   Dali::Radian *argp1 ;
9502   Dali::Degree *argp2 ;
9503   bool result;
9504
9505   argp1 = (Dali::Radian *)jarg1;
9506   if (!argp1) {
9507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9508     return 0;
9509   }
9510   arg1 = *argp1;
9511   argp2 = (Dali::Degree *)jarg2;
9512   if (!argp2) {
9513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9514     return 0;
9515   }
9516   arg2 = *argp2;
9517   {
9518     try {
9519       result = (bool)Dali::operator <(arg1,arg2);
9520     } catch (std::out_of_range& e) {
9521       {
9522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9523       };
9524     } catch (std::exception& e) {
9525       {
9526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9527       };
9528     } catch (...) {
9529       {
9530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9531       };
9532     }
9533   }
9534   jresult = result;
9535   return jresult;
9536 }
9537
9538
9539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9540   unsigned int jresult ;
9541   Dali::Degree arg1 ;
9542   Dali::Radian arg2 ;
9543   Dali::Degree *argp1 ;
9544   Dali::Radian *argp2 ;
9545   bool result;
9546
9547   argp1 = (Dali::Degree *)jarg1;
9548   if (!argp1) {
9549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9550     return 0;
9551   }
9552   arg1 = *argp1;
9553   argp2 = (Dali::Radian *)jarg2;
9554   if (!argp2) {
9555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9556     return 0;
9557   }
9558   arg2 = *argp2;
9559   {
9560     try {
9561       result = (bool)Dali::operator <(arg1,arg2);
9562     } catch (std::out_of_range& e) {
9563       {
9564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9565       };
9566     } catch (std::exception& e) {
9567       {
9568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9569       };
9570     } catch (...) {
9571       {
9572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9573       };
9574     }
9575   }
9576   jresult = result;
9577   return jresult;
9578 }
9579
9580
9581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9582   void * jresult ;
9583   Dali::Radian arg1 ;
9584   float arg2 ;
9585   Dali::Radian *argp1 ;
9586   Dali::Radian result;
9587
9588   argp1 = (Dali::Radian *)jarg1;
9589   if (!argp1) {
9590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9591     return 0;
9592   }
9593   arg1 = *argp1;
9594   arg2 = (float)jarg2;
9595   {
9596     try {
9597       result = Dali::operator *(arg1,arg2);
9598     } catch (std::out_of_range& e) {
9599       {
9600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9601       };
9602     } catch (std::exception& e) {
9603       {
9604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9605       };
9606     } catch (...) {
9607       {
9608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9609       };
9610     }
9611   }
9612   jresult = new Dali::Radian((const Dali::Radian &)result);
9613   return jresult;
9614 }
9615
9616
9617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9618   void * jresult ;
9619   Dali::Radian arg1 ;
9620   Dali::Radian *argp1 ;
9621   Dali::Radian result;
9622
9623   argp1 = (Dali::Radian *)jarg1;
9624   if (!argp1) {
9625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9626     return 0;
9627   }
9628   arg1 = *argp1;
9629   {
9630     try {
9631       result = Dali::operator -(arg1);
9632     } catch (std::out_of_range& e) {
9633       {
9634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9635       };
9636     } catch (std::exception& e) {
9637       {
9638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9639       };
9640     } catch (...) {
9641       {
9642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9643       };
9644     }
9645   }
9646   jresult = new Dali::Radian((const Dali::Radian &)result);
9647   return jresult;
9648 }
9649
9650
9651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9652   void * jresult ;
9653   Dali::Radian arg1 ;
9654   float arg2 ;
9655   float arg3 ;
9656   Dali::Radian *argp1 ;
9657   Dali::Radian result;
9658
9659   argp1 = (Dali::Radian *)jarg1;
9660   if (!argp1) {
9661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9662     return 0;
9663   }
9664   arg1 = *argp1;
9665   arg2 = (float)jarg2;
9666   arg3 = (float)jarg3;
9667   {
9668     try {
9669       result = Dali::Clamp(arg1,arg2,arg3);
9670     } catch (std::out_of_range& e) {
9671       {
9672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9673       };
9674     } catch (std::exception& e) {
9675       {
9676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9677       };
9678     } catch (...) {
9679       {
9680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9681       };
9682     }
9683   }
9684   jresult = new Dali::Radian((const Dali::Radian &)result);
9685   return jresult;
9686 }
9687
9688
9689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9690   void * jresult ;
9691   Dali::Quaternion *result = 0 ;
9692
9693   {
9694     try {
9695       result = (Dali::Quaternion *)new Dali::Quaternion();
9696     } catch (std::out_of_range& e) {
9697       {
9698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9699       };
9700     } catch (std::exception& e) {
9701       {
9702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9703       };
9704     } catch (...) {
9705       {
9706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9707       };
9708     }
9709   }
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9716   void * jresult ;
9717   Dali::Radian arg1 ;
9718   Dali::Vector3 *arg2 = 0 ;
9719   Dali::Radian *argp1 ;
9720   Dali::Quaternion *result = 0 ;
9721
9722   argp1 = (Dali::Radian *)jarg1;
9723   if (!argp1) {
9724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9725     return 0;
9726   }
9727   arg1 = *argp1;
9728   arg2 = (Dali::Vector3 *)jarg2;
9729   if (!arg2) {
9730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9731     return 0;
9732   }
9733   {
9734     try {
9735       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9736     } catch (std::out_of_range& e) {
9737       {
9738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (std::exception& e) {
9741       {
9742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9743       };
9744     } catch (...) {
9745       {
9746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9747       };
9748     }
9749   }
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9756   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9757
9758   arg1 = (Dali::Quaternion *)jarg1;
9759   {
9760     try {
9761       delete arg1;
9762     } catch (std::out_of_range& e) {
9763       {
9764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9765       };
9766     } catch (std::exception& e) {
9767       {
9768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9769       };
9770     } catch (...) {
9771       {
9772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9773       };
9774     }
9775   }
9776 }
9777
9778
9779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9780   void * jresult ;
9781   Dali::Quaternion *result = 0 ;
9782
9783   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9790   unsigned int jresult ;
9791   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9792   bool result;
9793
9794   arg1 = (Dali::Quaternion *)jarg1;
9795   {
9796     try {
9797       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9798     } catch (std::out_of_range& e) {
9799       {
9800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9801       };
9802     } catch (std::exception& e) {
9803       {
9804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9805       };
9806     } catch (...) {
9807       {
9808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9809       };
9810     }
9811   }
9812   jresult = result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9818   unsigned int jresult ;
9819   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9820   Dali::Vector3 *arg2 = 0 ;
9821   Dali::Radian *arg3 = 0 ;
9822   bool result;
9823
9824   arg1 = (Dali::Quaternion *)jarg1;
9825   arg2 = (Dali::Vector3 *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9828     return 0;
9829   }
9830   arg3 = (Dali::Radian *)jarg3;
9831   if (!arg3) {
9832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9833     return 0;
9834   }
9835   {
9836     try {
9837       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9838     } catch (std::out_of_range& e) {
9839       {
9840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (std::exception& e) {
9843       {
9844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9858   void * jresult ;
9859   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9860   Dali::Quaternion *arg2 = 0 ;
9861   Dali::Quaternion result;
9862
9863   arg1 = (Dali::Quaternion *)jarg1;
9864   arg2 = (Dali::Quaternion *)jarg2;
9865   if (!arg2) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9867     return 0;
9868   }
9869   {
9870     try {
9871       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9872     } catch (std::out_of_range& e) {
9873       {
9874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9875       };
9876     } catch (std::exception& e) {
9877       {
9878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (...) {
9881       {
9882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9883       };
9884     }
9885   }
9886   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9887   return jresult;
9888 }
9889
9890
9891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9892   void * jresult ;
9893   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9894   Dali::Quaternion *arg2 = 0 ;
9895   Dali::Quaternion result;
9896
9897   arg1 = (Dali::Quaternion *)jarg1;
9898   arg2 = (Dali::Quaternion *)jarg2;
9899   if (!arg2) {
9900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9901     return 0;
9902   }
9903   {
9904     try {
9905       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (...) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9917       };
9918     }
9919   }
9920   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9921   return jresult;
9922 }
9923
9924
9925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9926   void * jresult ;
9927   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9928   Dali::Quaternion *arg2 = 0 ;
9929   Dali::Quaternion result;
9930
9931   arg1 = (Dali::Quaternion *)jarg1;
9932   arg2 = (Dali::Quaternion *)jarg2;
9933   if (!arg2) {
9934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9935     return 0;
9936   }
9937   {
9938     try {
9939       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9940     } catch (std::out_of_range& e) {
9941       {
9942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (std::exception& e) {
9945       {
9946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9947       };
9948     } catch (...) {
9949       {
9950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9951       };
9952     }
9953   }
9954   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9955   return jresult;
9956 }
9957
9958
9959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9960   void * jresult ;
9961   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9962   Dali::Vector3 *arg2 = 0 ;
9963   Dali::Vector3 result;
9964
9965   arg1 = (Dali::Quaternion *)jarg1;
9966   arg2 = (Dali::Vector3 *)jarg2;
9967   if (!arg2) {
9968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9969     return 0;
9970   }
9971   {
9972     try {
9973       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9974     } catch (std::out_of_range& e) {
9975       {
9976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (std::exception& e) {
9979       {
9980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (...) {
9983       {
9984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9985       };
9986     }
9987   }
9988   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9989   return jresult;
9990 }
9991
9992
9993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9994   void * jresult ;
9995   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9996   Dali::Quaternion *arg2 = 0 ;
9997   Dali::Quaternion result;
9998
9999   arg1 = (Dali::Quaternion *)jarg1;
10000   arg2 = (Dali::Quaternion *)jarg2;
10001   if (!arg2) {
10002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10003     return 0;
10004   }
10005   {
10006     try {
10007       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10008     } catch (std::out_of_range& e) {
10009       {
10010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10011       };
10012     } catch (std::exception& e) {
10013       {
10014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10015       };
10016     } catch (...) {
10017       {
10018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10019       };
10020     }
10021   }
10022   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10023   return jresult;
10024 }
10025
10026
10027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10028   void * jresult ;
10029   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10030   float arg2 ;
10031   Dali::Quaternion result;
10032
10033   arg1 = (Dali::Quaternion *)jarg1;
10034   arg2 = (float)jarg2;
10035   {
10036     try {
10037       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10038     } catch (std::out_of_range& e) {
10039       {
10040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10041       };
10042     } catch (std::exception& e) {
10043       {
10044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10045       };
10046     } catch (...) {
10047       {
10048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10049       };
10050     }
10051   }
10052   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10053   return jresult;
10054 }
10055
10056
10057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10058   void * jresult ;
10059   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10060   float arg2 ;
10061   Dali::Quaternion result;
10062
10063   arg1 = (Dali::Quaternion *)jarg1;
10064   arg2 = (float)jarg2;
10065   {
10066     try {
10067       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10068     } catch (std::out_of_range& e) {
10069       {
10070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10071       };
10072     } catch (std::exception& e) {
10073       {
10074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10075       };
10076     } catch (...) {
10077       {
10078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10079       };
10080     }
10081   }
10082   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10083   return jresult;
10084 }
10085
10086
10087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10088   void * jresult ;
10089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10090   Dali::Quaternion result;
10091
10092   arg1 = (Dali::Quaternion *)jarg1;
10093   {
10094     try {
10095       result = ((Dali::Quaternion const *)arg1)->operator -();
10096     } catch (std::out_of_range& e) {
10097       {
10098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10099       };
10100     } catch (std::exception& e) {
10101       {
10102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (...) {
10105       {
10106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10107       };
10108     }
10109   }
10110   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10111   return jresult;
10112 }
10113
10114
10115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10116   void * jresult ;
10117   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10118   Dali::Quaternion *arg2 = 0 ;
10119   Dali::Quaternion *result = 0 ;
10120
10121   arg1 = (Dali::Quaternion *)jarg1;
10122   arg2 = (Dali::Quaternion *)jarg2;
10123   if (!arg2) {
10124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10125     return 0;
10126   }
10127   {
10128     try {
10129       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10130     } catch (std::out_of_range& e) {
10131       {
10132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (std::exception& e) {
10135       {
10136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (...) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10141       };
10142     }
10143   }
10144   jresult = (void *)result;
10145   return jresult;
10146 }
10147
10148
10149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10150   void * jresult ;
10151   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10152   Dali::Quaternion *arg2 = 0 ;
10153   Dali::Quaternion *result = 0 ;
10154
10155   arg1 = (Dali::Quaternion *)jarg1;
10156   arg2 = (Dali::Quaternion *)jarg2;
10157   if (!arg2) {
10158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10159     return 0;
10160   }
10161   {
10162     try {
10163       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10164     } catch (std::out_of_range& e) {
10165       {
10166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10167       };
10168     } catch (std::exception& e) {
10169       {
10170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10171       };
10172     } catch (...) {
10173       {
10174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10175       };
10176     }
10177   }
10178   jresult = (void *)result;
10179   return jresult;
10180 }
10181
10182
10183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10184   void * jresult ;
10185   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10186   Dali::Quaternion *arg2 = 0 ;
10187   Dali::Quaternion *result = 0 ;
10188
10189   arg1 = (Dali::Quaternion *)jarg1;
10190   arg2 = (Dali::Quaternion *)jarg2;
10191   if (!arg2) {
10192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10193     return 0;
10194   }
10195   {
10196     try {
10197       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10198     } catch (std::out_of_range& e) {
10199       {
10200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10201       };
10202     } catch (std::exception& e) {
10203       {
10204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10205       };
10206     } catch (...) {
10207       {
10208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10209       };
10210     }
10211   }
10212   jresult = (void *)result;
10213   return jresult;
10214 }
10215
10216
10217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10218   void * jresult ;
10219   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10220   float arg2 ;
10221   Dali::Quaternion *result = 0 ;
10222
10223   arg1 = (Dali::Quaternion *)jarg1;
10224   arg2 = (float)jarg2;
10225   {
10226     try {
10227       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10228     } catch (std::out_of_range& e) {
10229       {
10230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (std::exception& e) {
10233       {
10234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (...) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10239       };
10240     }
10241   }
10242   jresult = (void *)result;
10243   return jresult;
10244 }
10245
10246
10247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10248   void * jresult ;
10249   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10250   float arg2 ;
10251   Dali::Quaternion *result = 0 ;
10252
10253   arg1 = (Dali::Quaternion *)jarg1;
10254   arg2 = (float)jarg2;
10255   {
10256     try {
10257       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10258     } catch (std::out_of_range& e) {
10259       {
10260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10261       };
10262     } catch (std::exception& e) {
10263       {
10264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10265       };
10266     } catch (...) {
10267       {
10268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10269       };
10270     }
10271   }
10272   jresult = (void *)result;
10273   return jresult;
10274 }
10275
10276
10277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10278   unsigned int jresult ;
10279   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10280   Dali::Quaternion *arg2 = 0 ;
10281   bool result;
10282
10283   arg1 = (Dali::Quaternion *)jarg1;
10284   arg2 = (Dali::Quaternion *)jarg2;
10285   if (!arg2) {
10286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10287     return 0;
10288   }
10289   {
10290     try {
10291       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10292     } catch (std::out_of_range& e) {
10293       {
10294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10295       };
10296     } catch (std::exception& e) {
10297       {
10298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10299       };
10300     } catch (...) {
10301       {
10302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10303       };
10304     }
10305   }
10306   jresult = result;
10307   return jresult;
10308 }
10309
10310
10311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10312   unsigned int jresult ;
10313   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10314   Dali::Quaternion *arg2 = 0 ;
10315   bool result;
10316
10317   arg1 = (Dali::Quaternion *)jarg1;
10318   arg2 = (Dali::Quaternion *)jarg2;
10319   if (!arg2) {
10320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10321     return 0;
10322   }
10323   {
10324     try {
10325       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (...) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10337       };
10338     }
10339   }
10340   jresult = result;
10341   return jresult;
10342 }
10343
10344
10345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10346   float jresult ;
10347   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10348   float result;
10349
10350   arg1 = (Dali::Quaternion *)jarg1;
10351   {
10352     try {
10353       result = (float)((Dali::Quaternion const *)arg1)->Length();
10354     } catch (std::out_of_range& e) {
10355       {
10356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10357       };
10358     } catch (std::exception& e) {
10359       {
10360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (...) {
10363       {
10364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10365       };
10366     }
10367   }
10368   jresult = result;
10369   return jresult;
10370 }
10371
10372
10373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10374   float jresult ;
10375   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10376   float result;
10377
10378   arg1 = (Dali::Quaternion *)jarg1;
10379   {
10380     try {
10381       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10382     } catch (std::out_of_range& e) {
10383       {
10384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10385       };
10386     } catch (std::exception& e) {
10387       {
10388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10389       };
10390     } catch (...) {
10391       {
10392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10393       };
10394     }
10395   }
10396   jresult = result;
10397   return jresult;
10398 }
10399
10400
10401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10402   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10403
10404   arg1 = (Dali::Quaternion *)jarg1;
10405   {
10406     try {
10407       (arg1)->Normalize();
10408     } catch (std::out_of_range& e) {
10409       {
10410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10411       };
10412     } catch (std::exception& e) {
10413       {
10414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10415       };
10416     } catch (...) {
10417       {
10418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10419       };
10420     }
10421   }
10422 }
10423
10424
10425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10426   void * jresult ;
10427   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10428   Dali::Quaternion result;
10429
10430   arg1 = (Dali::Quaternion *)jarg1;
10431   {
10432     try {
10433       result = ((Dali::Quaternion const *)arg1)->Normalized();
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (...) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10445       };
10446     }
10447   }
10448   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10449   return jresult;
10450 }
10451
10452
10453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10454   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10455
10456   arg1 = (Dali::Quaternion *)jarg1;
10457   {
10458     try {
10459       (arg1)->Conjugate();
10460     } catch (std::out_of_range& e) {
10461       {
10462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10463       };
10464     } catch (std::exception& e) {
10465       {
10466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10467       };
10468     } catch (...) {
10469       {
10470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10471       };
10472     }
10473   }
10474 }
10475
10476
10477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10478   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10479
10480   arg1 = (Dali::Quaternion *)jarg1;
10481   {
10482     try {
10483       (arg1)->Invert();
10484     } catch (std::out_of_range& e) {
10485       {
10486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10487       };
10488     } catch (std::exception& e) {
10489       {
10490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10491       };
10492     } catch (...) {
10493       {
10494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10495       };
10496     }
10497   }
10498 }
10499
10500
10501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10502   void * jresult ;
10503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10504   Dali::Quaternion result;
10505
10506   arg1 = (Dali::Quaternion *)jarg1;
10507   {
10508     try {
10509       result = ((Dali::Quaternion const *)arg1)->Log();
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10525   return jresult;
10526 }
10527
10528
10529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10530   void * jresult ;
10531   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10532   Dali::Quaternion result;
10533
10534   arg1 = (Dali::Quaternion *)jarg1;
10535   {
10536     try {
10537       result = ((Dali::Quaternion const *)arg1)->Exp();
10538     } catch (std::out_of_range& e) {
10539       {
10540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10541       };
10542     } catch (std::exception& e) {
10543       {
10544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10545       };
10546     } catch (...) {
10547       {
10548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10549       };
10550     }
10551   }
10552   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10553   return jresult;
10554 }
10555
10556
10557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10558   float jresult ;
10559   Dali::Quaternion *arg1 = 0 ;
10560   Dali::Quaternion *arg2 = 0 ;
10561   float result;
10562
10563   arg1 = (Dali::Quaternion *)jarg1;
10564   if (!arg1) {
10565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10566     return 0;
10567   }
10568   arg2 = (Dali::Quaternion *)jarg2;
10569   if (!arg2) {
10570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10571     return 0;
10572   }
10573   {
10574     try {
10575       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10576     } catch (std::out_of_range& e) {
10577       {
10578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10579       };
10580     } catch (std::exception& e) {
10581       {
10582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10583       };
10584     } catch (...) {
10585       {
10586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10587       };
10588     }
10589   }
10590   jresult = result;
10591   return jresult;
10592 }
10593
10594
10595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10596   void * jresult ;
10597   Dali::Quaternion *arg1 = 0 ;
10598   Dali::Quaternion *arg2 = 0 ;
10599   float arg3 ;
10600   Dali::Quaternion result;
10601
10602   arg1 = (Dali::Quaternion *)jarg1;
10603   if (!arg1) {
10604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10605     return 0;
10606   }
10607   arg2 = (Dali::Quaternion *)jarg2;
10608   if (!arg2) {
10609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10610     return 0;
10611   }
10612   arg3 = (float)jarg3;
10613   {
10614     try {
10615       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10616     } catch (std::out_of_range& e) {
10617       {
10618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10619       };
10620     } catch (std::exception& e) {
10621       {
10622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10623       };
10624     } catch (...) {
10625       {
10626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10627       };
10628     }
10629   }
10630   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10631   return jresult;
10632 }
10633
10634
10635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10636   void * jresult ;
10637   Dali::Quaternion *arg1 = 0 ;
10638   Dali::Quaternion *arg2 = 0 ;
10639   float arg3 ;
10640   Dali::Quaternion result;
10641
10642   arg1 = (Dali::Quaternion *)jarg1;
10643   if (!arg1) {
10644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10645     return 0;
10646   }
10647   arg2 = (Dali::Quaternion *)jarg2;
10648   if (!arg2) {
10649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10650     return 0;
10651   }
10652   arg3 = (float)jarg3;
10653   {
10654     try {
10655       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10656     } catch (std::out_of_range& e) {
10657       {
10658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (std::exception& e) {
10661       {
10662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10676   void * jresult ;
10677   Dali::Quaternion *arg1 = 0 ;
10678   Dali::Quaternion *arg2 = 0 ;
10679   float arg3 ;
10680   Dali::Quaternion result;
10681
10682   arg1 = (Dali::Quaternion *)jarg1;
10683   if (!arg1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10685     return 0;
10686   }
10687   arg2 = (Dali::Quaternion *)jarg2;
10688   if (!arg2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10690     return 0;
10691   }
10692   arg3 = (float)jarg3;
10693   {
10694     try {
10695       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (...) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10707       };
10708     }
10709   }
10710   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10711   return jresult;
10712 }
10713
10714
10715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10716   void * jresult ;
10717   Dali::Quaternion *arg1 = 0 ;
10718   Dali::Quaternion *arg2 = 0 ;
10719   Dali::Quaternion *arg3 = 0 ;
10720   Dali::Quaternion *arg4 = 0 ;
10721   float arg5 ;
10722   Dali::Quaternion result;
10723
10724   arg1 = (Dali::Quaternion *)jarg1;
10725   if (!arg1) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10727     return 0;
10728   }
10729   arg2 = (Dali::Quaternion *)jarg2;
10730   if (!arg2) {
10731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10732     return 0;
10733   }
10734   arg3 = (Dali::Quaternion *)jarg3;
10735   if (!arg3) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10737     return 0;
10738   }
10739   arg4 = (Dali::Quaternion *)jarg4;
10740   if (!arg4) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10742     return 0;
10743   }
10744   arg5 = (float)jarg5;
10745   {
10746     try {
10747       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10748     } catch (std::out_of_range& e) {
10749       {
10750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10751       };
10752     } catch (std::exception& e) {
10753       {
10754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10755       };
10756     } catch (...) {
10757       {
10758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10759       };
10760     }
10761   }
10762   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10768   float jresult ;
10769   Dali::Quaternion *arg1 = 0 ;
10770   Dali::Quaternion *arg2 = 0 ;
10771   float result;
10772
10773   arg1 = (Dali::Quaternion *)jarg1;
10774   if (!arg1) {
10775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10776     return 0;
10777   }
10778   arg2 = (Dali::Quaternion *)jarg2;
10779   if (!arg2) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10781     return 0;
10782   }
10783   {
10784     try {
10785       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10786     } catch (std::out_of_range& e) {
10787       {
10788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (std::exception& e) {
10791       {
10792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800   jresult = result;
10801   return jresult;
10802 }
10803
10804
10805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10806   void * jresult ;
10807   Dali::Matrix *result = 0 ;
10808
10809   {
10810     try {
10811       result = (Dali::Matrix *)new Dali::Matrix();
10812     } catch (std::out_of_range& e) {
10813       {
10814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10815       };
10816     } catch (std::exception& e) {
10817       {
10818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10819       };
10820     } catch (...) {
10821       {
10822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10823       };
10824     }
10825   }
10826   jresult = (void *)result;
10827   return jresult;
10828 }
10829
10830
10831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10832   void * jresult ;
10833   bool arg1 ;
10834   Dali::Matrix *result = 0 ;
10835
10836   arg1 = jarg1 ? true : false;
10837   {
10838     try {
10839       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10840     } catch (std::out_of_range& e) {
10841       {
10842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10843       };
10844     } catch (std::exception& e) {
10845       {
10846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10847       };
10848     } catch (...) {
10849       {
10850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10851       };
10852     }
10853   }
10854   jresult = (void *)result;
10855   return jresult;
10856 }
10857
10858
10859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10860   void * jresult ;
10861   float *arg1 = (float *) 0 ;
10862   Dali::Matrix *result = 0 ;
10863
10864   arg1 = jarg1;
10865   {
10866     try {
10867       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10868     } catch (std::out_of_range& e) {
10869       {
10870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (std::exception& e) {
10873       {
10874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (...) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10879       };
10880     }
10881   }
10882   jresult = (void *)result;
10883
10884
10885   return jresult;
10886 }
10887
10888
10889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10890   void * jresult ;
10891   Dali::Quaternion *arg1 = 0 ;
10892   Dali::Matrix *result = 0 ;
10893
10894   arg1 = (Dali::Quaternion *)jarg1;
10895   if (!arg1) {
10896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10897     return 0;
10898   }
10899   {
10900     try {
10901       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10902     } catch (std::out_of_range& e) {
10903       {
10904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (std::exception& e) {
10907       {
10908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10922   void * jresult ;
10923   Dali::Matrix *arg1 = 0 ;
10924   Dali::Matrix *result = 0 ;
10925
10926   arg1 = (Dali::Matrix *)jarg1;
10927   if (!arg1) {
10928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10929     return 0;
10930   }
10931   {
10932     try {
10933       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10934     } catch (std::out_of_range& e) {
10935       {
10936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10937       };
10938     } catch (std::exception& e) {
10939       {
10940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10941       };
10942     } catch (...) {
10943       {
10944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10945       };
10946     }
10947   }
10948   jresult = (void *)result;
10949   return jresult;
10950 }
10951
10952
10953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10954   void * jresult ;
10955   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10956   Dali::Matrix *arg2 = 0 ;
10957   Dali::Matrix *result = 0 ;
10958
10959   arg1 = (Dali::Matrix *)jarg1;
10960   arg2 = (Dali::Matrix *)jarg2;
10961   if (!arg2) {
10962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10963     return 0;
10964   }
10965   {
10966     try {
10967       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10968     } catch (std::out_of_range& e) {
10969       {
10970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (std::exception& e) {
10973       {
10974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10975       };
10976     } catch (...) {
10977       {
10978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10979       };
10980     }
10981   }
10982   jresult = (void *)result;
10983   return jresult;
10984 }
10985
10986
10987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10988   void * jresult ;
10989   Dali::Matrix *result = 0 ;
10990
10991   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10992   jresult = (void *)result;
10993   return jresult;
10994 }
10995
10996
10997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10998   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10999
11000   arg1 = (Dali::Matrix *)jarg1;
11001   {
11002     try {
11003       (arg1)->SetIdentity();
11004     } catch (std::out_of_range& e) {
11005       {
11006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11007       };
11008     } catch (std::exception& e) {
11009       {
11010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11011       };
11012     } catch (...) {
11013       {
11014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11015       };
11016     }
11017   }
11018 }
11019
11020
11021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11022   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11023   Dali::Vector3 *arg2 = 0 ;
11024
11025   arg1 = (Dali::Matrix *)jarg1;
11026   arg2 = (Dali::Vector3 *)jarg2;
11027   if (!arg2) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11029     return ;
11030   }
11031   {
11032     try {
11033       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11045       };
11046     }
11047   }
11048 }
11049
11050
11051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11052   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11053   Dali::Matrix *arg2 = 0 ;
11054
11055   arg1 = (Dali::Matrix *)jarg1;
11056   arg2 = (Dali::Matrix *)jarg2;
11057   if (!arg2) {
11058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11059     return ;
11060   }
11061   {
11062     try {
11063       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11064     } catch (std::out_of_range& e) {
11065       {
11066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11067       };
11068     } catch (std::exception& e) {
11069       {
11070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11071       };
11072     } catch (...) {
11073       {
11074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11075       };
11076     }
11077   }
11078 }
11079
11080
11081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11082   unsigned int jresult ;
11083   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11084   bool result;
11085
11086   arg1 = (Dali::Matrix *)jarg1;
11087   {
11088     try {
11089       result = (bool)(arg1)->Invert();
11090     } catch (std::out_of_range& e) {
11091       {
11092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11093       };
11094     } catch (std::exception& e) {
11095       {
11096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11097       };
11098     } catch (...) {
11099       {
11100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11101       };
11102     }
11103   }
11104   jresult = result;
11105   return jresult;
11106 }
11107
11108
11109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11110   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11111
11112   arg1 = (Dali::Matrix *)jarg1;
11113   {
11114     try {
11115       (arg1)->Transpose();
11116     } catch (std::out_of_range& e) {
11117       {
11118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11119       };
11120     } catch (std::exception& e) {
11121       {
11122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11123       };
11124     } catch (...) {
11125       {
11126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11127       };
11128     }
11129   }
11130 }
11131
11132
11133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11134   void * jresult ;
11135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11136   Dali::Vector3 result;
11137
11138   arg1 = (Dali::Matrix *)jarg1;
11139   {
11140     try {
11141       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11142     } catch (std::out_of_range& e) {
11143       {
11144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11145       };
11146     } catch (std::exception& e) {
11147       {
11148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11149       };
11150     } catch (...) {
11151       {
11152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11153       };
11154     }
11155   }
11156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11157   return jresult;
11158 }
11159
11160
11161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11162   void * jresult ;
11163   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11164   Dali::Vector3 result;
11165
11166   arg1 = (Dali::Matrix *)jarg1;
11167   {
11168     try {
11169       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11170     } catch (std::out_of_range& e) {
11171       {
11172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (std::exception& e) {
11175       {
11176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11185   return jresult;
11186 }
11187
11188
11189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11190   void * jresult ;
11191   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11192   Dali::Vector3 result;
11193
11194   arg1 = (Dali::Matrix *)jarg1;
11195   {
11196     try {
11197       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11198     } catch (std::out_of_range& e) {
11199       {
11200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11201       };
11202     } catch (std::exception& e) {
11203       {
11204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11205       };
11206     } catch (...) {
11207       {
11208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11209       };
11210     }
11211   }
11212   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11213   return jresult;
11214 }
11215
11216
11217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11218   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11219   Dali::Vector3 *arg2 = 0 ;
11220
11221   arg1 = (Dali::Matrix *)jarg1;
11222   arg2 = (Dali::Vector3 *)jarg2;
11223   if (!arg2) {
11224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11225     return ;
11226   }
11227   {
11228     try {
11229       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11230     } catch (std::out_of_range& e) {
11231       {
11232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11233       };
11234     } catch (std::exception& e) {
11235       {
11236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11237       };
11238     } catch (...) {
11239       {
11240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11241       };
11242     }
11243   }
11244 }
11245
11246
11247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11248   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11249   Dali::Vector3 *arg2 = 0 ;
11250
11251   arg1 = (Dali::Matrix *)jarg1;
11252   arg2 = (Dali::Vector3 *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11255     return ;
11256   }
11257   {
11258     try {
11259       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11267       };
11268     } catch (...) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11271       };
11272     }
11273   }
11274 }
11275
11276
11277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11278   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11279   Dali::Vector3 *arg2 = 0 ;
11280
11281   arg1 = (Dali::Matrix *)jarg1;
11282   arg2 = (Dali::Vector3 *)jarg2;
11283   if (!arg2) {
11284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11285     return ;
11286   }
11287   {
11288     try {
11289       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11290     } catch (std::out_of_range& e) {
11291       {
11292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11293       };
11294     } catch (std::exception& e) {
11295       {
11296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11297       };
11298     } catch (...) {
11299       {
11300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11301       };
11302     }
11303   }
11304 }
11305
11306
11307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11308   void * jresult ;
11309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11310   Dali::Vector4 *result = 0 ;
11311
11312   arg1 = (Dali::Matrix *)jarg1;
11313   {
11314     try {
11315       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11316     } catch (std::out_of_range& e) {
11317       {
11318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11319       };
11320     } catch (std::exception& e) {
11321       {
11322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11323       };
11324     } catch (...) {
11325       {
11326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11327       };
11328     }
11329   }
11330   jresult = (void *)result;
11331   return jresult;
11332 }
11333
11334
11335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11336   void * jresult ;
11337   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11338   Dali::Vector3 *result = 0 ;
11339
11340   arg1 = (Dali::Matrix *)jarg1;
11341   {
11342     try {
11343       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11344     } catch (std::out_of_range& e) {
11345       {
11346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11347       };
11348     } catch (std::exception& e) {
11349       {
11350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11351       };
11352     } catch (...) {
11353       {
11354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11355       };
11356     }
11357   }
11358   jresult = (void *)result;
11359   return jresult;
11360 }
11361
11362
11363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11365   Dali::Vector4 *arg2 = 0 ;
11366
11367   arg1 = (Dali::Matrix *)jarg1;
11368   arg2 = (Dali::Vector4 *)jarg2;
11369   if (!arg2) {
11370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11371     return ;
11372   }
11373   {
11374     try {
11375       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11376     } catch (std::out_of_range& e) {
11377       {
11378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11379       };
11380     } catch (std::exception& e) {
11381       {
11382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11383       };
11384     } catch (...) {
11385       {
11386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11387       };
11388     }
11389   }
11390 }
11391
11392
11393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11394   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11395   Dali::Vector3 *arg2 = 0 ;
11396
11397   arg1 = (Dali::Matrix *)jarg1;
11398   arg2 = (Dali::Vector3 *)jarg2;
11399   if (!arg2) {
11400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11401     return ;
11402   }
11403   {
11404     try {
11405       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11406     } catch (std::out_of_range& e) {
11407       {
11408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11409       };
11410     } catch (std::exception& e) {
11411       {
11412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11417       };
11418     }
11419   }
11420 }
11421
11422
11423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11424   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11425
11426   arg1 = (Dali::Matrix *)jarg1;
11427   {
11428     try {
11429       (arg1)->OrthoNormalize();
11430     } catch (std::out_of_range& e) {
11431       {
11432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11433       };
11434     } catch (std::exception& e) {
11435       {
11436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11437       };
11438     } catch (...) {
11439       {
11440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11441       };
11442     }
11443   }
11444 }
11445
11446
11447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11448   void * jresult ;
11449   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11450   float *result = 0 ;
11451
11452   arg1 = (Dali::Matrix *)jarg1;
11453   {
11454     try {
11455       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11456     } catch (std::out_of_range& e) {
11457       {
11458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11459       };
11460     } catch (std::exception& e) {
11461       {
11462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11463       };
11464     } catch (...) {
11465       {
11466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11467       };
11468     }
11469   }
11470   jresult = (void *)result;
11471   return jresult;
11472 }
11473
11474
11475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11476   Dali::Matrix *arg1 = 0 ;
11477   Dali::Matrix *arg2 = 0 ;
11478   Dali::Matrix *arg3 = 0 ;
11479
11480   arg1 = (Dali::Matrix *)jarg1;
11481   if (!arg1) {
11482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11483     return ;
11484   }
11485   arg2 = (Dali::Matrix *)jarg2;
11486   if (!arg2) {
11487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11488     return ;
11489   }
11490   arg3 = (Dali::Matrix *)jarg3;
11491   if (!arg3) {
11492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11493     return ;
11494   }
11495   {
11496     try {
11497       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11498     } catch (std::out_of_range& e) {
11499       {
11500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11501       };
11502     } catch (std::exception& e) {
11503       {
11504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11505       };
11506     } catch (...) {
11507       {
11508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11509       };
11510     }
11511   }
11512 }
11513
11514
11515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11516   Dali::Matrix *arg1 = 0 ;
11517   Dali::Matrix *arg2 = 0 ;
11518   Dali::Quaternion *arg3 = 0 ;
11519
11520   arg1 = (Dali::Matrix *)jarg1;
11521   if (!arg1) {
11522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11523     return ;
11524   }
11525   arg2 = (Dali::Matrix *)jarg2;
11526   if (!arg2) {
11527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11528     return ;
11529   }
11530   arg3 = (Dali::Quaternion *)jarg3;
11531   if (!arg3) {
11532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11533     return ;
11534   }
11535   {
11536     try {
11537       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11538     } catch (std::out_of_range& e) {
11539       {
11540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11541       };
11542     } catch (std::exception& e) {
11543       {
11544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11545       };
11546     } catch (...) {
11547       {
11548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11549       };
11550     }
11551   }
11552 }
11553
11554
11555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11556   void * jresult ;
11557   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11558   Dali::Vector4 *arg2 = 0 ;
11559   Dali::Vector4 result;
11560
11561   arg1 = (Dali::Matrix *)jarg1;
11562   arg2 = (Dali::Vector4 *)jarg2;
11563   if (!arg2) {
11564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11565     return 0;
11566   }
11567   {
11568     try {
11569       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11570     } catch (std::out_of_range& e) {
11571       {
11572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11573       };
11574     } catch (std::exception& e) {
11575       {
11576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11577       };
11578     } catch (...) {
11579       {
11580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11581       };
11582     }
11583   }
11584   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11585   return jresult;
11586 }
11587
11588
11589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11590   unsigned int jresult ;
11591   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11592   Dali::Matrix *arg2 = 0 ;
11593   bool result;
11594
11595   arg1 = (Dali::Matrix *)jarg1;
11596   arg2 = (Dali::Matrix *)jarg2;
11597   if (!arg2) {
11598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11599     return 0;
11600   }
11601   {
11602     try {
11603       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11604     } catch (std::out_of_range& e) {
11605       {
11606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11607       };
11608     } catch (std::exception& e) {
11609       {
11610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11611       };
11612     } catch (...) {
11613       {
11614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11615       };
11616     }
11617   }
11618   jresult = result;
11619   return jresult;
11620 }
11621
11622
11623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11624   unsigned int jresult ;
11625   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11626   Dali::Matrix *arg2 = 0 ;
11627   bool result;
11628
11629   arg1 = (Dali::Matrix *)jarg1;
11630   arg2 = (Dali::Matrix *)jarg2;
11631   if (!arg2) {
11632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11633     return 0;
11634   }
11635   {
11636     try {
11637       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11638     } catch (std::out_of_range& e) {
11639       {
11640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11641       };
11642     } catch (std::exception& e) {
11643       {
11644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11645       };
11646     } catch (...) {
11647       {
11648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11649       };
11650     }
11651   }
11652   jresult = result;
11653   return jresult;
11654 }
11655
11656
11657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11658   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11659   Dali::Vector3 *arg2 = 0 ;
11660   Dali::Quaternion *arg3 = 0 ;
11661   Dali::Vector3 *arg4 = 0 ;
11662
11663   arg1 = (Dali::Matrix *)jarg1;
11664   arg2 = (Dali::Vector3 *)jarg2;
11665   if (!arg2) {
11666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11667     return ;
11668   }
11669   arg3 = (Dali::Quaternion *)jarg3;
11670   if (!arg3) {
11671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11672     return ;
11673   }
11674   arg4 = (Dali::Vector3 *)jarg4;
11675   if (!arg4) {
11676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11677     return ;
11678   }
11679   {
11680     try {
11681       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11682     } catch (std::out_of_range& e) {
11683       {
11684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11685       };
11686     } catch (std::exception& e) {
11687       {
11688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11693       };
11694     }
11695   }
11696 }
11697
11698
11699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11701   Dali::Vector3 *arg2 = 0 ;
11702   Dali::Quaternion *arg3 = 0 ;
11703   Dali::Vector3 *arg4 = 0 ;
11704
11705   arg1 = (Dali::Matrix *)jarg1;
11706   arg2 = (Dali::Vector3 *)jarg2;
11707   if (!arg2) {
11708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11709     return ;
11710   }
11711   arg3 = (Dali::Quaternion *)jarg3;
11712   if (!arg3) {
11713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11714     return ;
11715   }
11716   arg4 = (Dali::Vector3 *)jarg4;
11717   if (!arg4) {
11718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11719     return ;
11720   }
11721   {
11722     try {
11723       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11724     } catch (std::out_of_range& e) {
11725       {
11726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11727       };
11728     } catch (std::exception& e) {
11729       {
11730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11731       };
11732     } catch (...) {
11733       {
11734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11735       };
11736     }
11737   }
11738 }
11739
11740
11741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11742   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11743   Dali::Vector3 *arg2 = 0 ;
11744   Dali::Vector3 *arg3 = 0 ;
11745   Dali::Vector3 *arg4 = 0 ;
11746   Dali::Vector3 *arg5 = 0 ;
11747
11748   arg1 = (Dali::Matrix *)jarg1;
11749   arg2 = (Dali::Vector3 *)jarg2;
11750   if (!arg2) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11752     return ;
11753   }
11754   arg3 = (Dali::Vector3 *)jarg3;
11755   if (!arg3) {
11756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11757     return ;
11758   }
11759   arg4 = (Dali::Vector3 *)jarg4;
11760   if (!arg4) {
11761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11762     return ;
11763   }
11764   arg5 = (Dali::Vector3 *)jarg5;
11765   if (!arg5) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11767     return ;
11768   }
11769   {
11770     try {
11771       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11772     } catch (std::out_of_range& e) {
11773       {
11774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11775       };
11776     } catch (std::exception& e) {
11777       {
11778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11779       };
11780     } catch (...) {
11781       {
11782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11783       };
11784     }
11785   }
11786 }
11787
11788
11789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11790   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11791   Dali::Vector3 *arg2 = 0 ;
11792   Dali::Quaternion *arg3 = 0 ;
11793   Dali::Vector3 *arg4 = 0 ;
11794
11795   arg1 = (Dali::Matrix *)jarg1;
11796   arg2 = (Dali::Vector3 *)jarg2;
11797   if (!arg2) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11799     return ;
11800   }
11801   arg3 = (Dali::Quaternion *)jarg3;
11802   if (!arg3) {
11803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11804     return ;
11805   }
11806   arg4 = (Dali::Vector3 *)jarg4;
11807   if (!arg4) {
11808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11809     return ;
11810   }
11811   {
11812     try {
11813       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (...) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11825       };
11826     }
11827   }
11828 }
11829
11830
11831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11832   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11833
11834   arg1 = (Dali::Matrix *)jarg1;
11835   {
11836     try {
11837       delete arg1;
11838     } catch (std::out_of_range& e) {
11839       {
11840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11841       };
11842     } catch (std::exception& e) {
11843       {
11844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11845       };
11846     } catch (...) {
11847       {
11848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11849       };
11850     }
11851   }
11852 }
11853
11854
11855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11856   void * jresult ;
11857   Dali::Matrix3 *result = 0 ;
11858
11859   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11860   jresult = (void *)result;
11861   return jresult;
11862 }
11863
11864
11865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11866   void * jresult ;
11867   Dali::Matrix3 *result = 0 ;
11868
11869   {
11870     try {
11871       result = (Dali::Matrix3 *)new Dali::Matrix3();
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (...) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11883       };
11884     }
11885   }
11886   jresult = (void *)result;
11887   return jresult;
11888 }
11889
11890
11891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11892   void * jresult ;
11893   Dali::Matrix3 *arg1 = 0 ;
11894   Dali::Matrix3 *result = 0 ;
11895
11896   arg1 = (Dali::Matrix3 *)jarg1;
11897   if (!arg1) {
11898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11899     return 0;
11900   }
11901   {
11902     try {
11903       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11904     } catch (std::out_of_range& e) {
11905       {
11906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11907       };
11908     } catch (std::exception& e) {
11909       {
11910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11911       };
11912     } catch (...) {
11913       {
11914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11915       };
11916     }
11917   }
11918   jresult = (void *)result;
11919   return jresult;
11920 }
11921
11922
11923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11924   void * jresult ;
11925   Dali::Matrix *arg1 = 0 ;
11926   Dali::Matrix3 *result = 0 ;
11927
11928   arg1 = (Dali::Matrix *)jarg1;
11929   if (!arg1) {
11930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11931     return 0;
11932   }
11933   {
11934     try {
11935       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11936     } catch (std::out_of_range& e) {
11937       {
11938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11939       };
11940     } catch (std::exception& e) {
11941       {
11942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11943       };
11944     } catch (...) {
11945       {
11946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11947       };
11948     }
11949   }
11950   jresult = (void *)result;
11951   return jresult;
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
11956   void * jresult ;
11957   float arg1 ;
11958   float arg2 ;
11959   float arg3 ;
11960   float arg4 ;
11961   float arg5 ;
11962   float arg6 ;
11963   float arg7 ;
11964   float arg8 ;
11965   float arg9 ;
11966   Dali::Matrix3 *result = 0 ;
11967
11968   arg1 = (float)jarg1;
11969   arg2 = (float)jarg2;
11970   arg3 = (float)jarg3;
11971   arg4 = (float)jarg4;
11972   arg5 = (float)jarg5;
11973   arg6 = (float)jarg6;
11974   arg7 = (float)jarg7;
11975   arg8 = (float)jarg8;
11976   arg9 = (float)jarg9;
11977   {
11978     try {
11979       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (...) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11991       };
11992     }
11993   }
11994   jresult = (void *)result;
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12000   void * jresult ;
12001   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12002   Dali::Matrix3 *arg2 = 0 ;
12003   Dali::Matrix3 *result = 0 ;
12004
12005   arg1 = (Dali::Matrix3 *)jarg1;
12006   arg2 = (Dali::Matrix3 *)jarg2;
12007   if (!arg2) {
12008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12009     return 0;
12010   }
12011   {
12012     try {
12013       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12014     } catch (std::out_of_range& e) {
12015       {
12016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (std::exception& e) {
12019       {
12020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028   jresult = (void *)result;
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12034   void * jresult ;
12035   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12036   Dali::Matrix *arg2 = 0 ;
12037   Dali::Matrix3 *result = 0 ;
12038
12039   arg1 = (Dali::Matrix3 *)jarg1;
12040   arg2 = (Dali::Matrix *)jarg2;
12041   if (!arg2) {
12042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12043     return 0;
12044   }
12045   {
12046     try {
12047       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12048     } catch (std::out_of_range& e) {
12049       {
12050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12051       };
12052     } catch (std::exception& e) {
12053       {
12054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12055       };
12056     } catch (...) {
12057       {
12058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12059       };
12060     }
12061   }
12062   jresult = (void *)result;
12063   return jresult;
12064 }
12065
12066
12067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12068   unsigned int jresult ;
12069   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12070   Dali::Matrix3 *arg2 = 0 ;
12071   bool result;
12072
12073   arg1 = (Dali::Matrix3 *)jarg1;
12074   arg2 = (Dali::Matrix3 *)jarg2;
12075   if (!arg2) {
12076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12077     return 0;
12078   }
12079   {
12080     try {
12081       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12082     } catch (std::out_of_range& e) {
12083       {
12084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (std::exception& e) {
12087       {
12088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12089       };
12090     } catch (...) {
12091       {
12092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12093       };
12094     }
12095   }
12096   jresult = result;
12097   return jresult;
12098 }
12099
12100
12101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12102   unsigned int jresult ;
12103   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12104   Dali::Matrix3 *arg2 = 0 ;
12105   bool result;
12106
12107   arg1 = (Dali::Matrix3 *)jarg1;
12108   arg2 = (Dali::Matrix3 *)jarg2;
12109   if (!arg2) {
12110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12111     return 0;
12112   }
12113   {
12114     try {
12115       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12116     } catch (std::out_of_range& e) {
12117       {
12118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (std::exception& e) {
12121       {
12122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130   jresult = result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12136   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12137
12138   arg1 = (Dali::Matrix3 *)jarg1;
12139   {
12140     try {
12141       delete arg1;
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12149       };
12150     } catch (...) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12153       };
12154     }
12155   }
12156 }
12157
12158
12159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12160   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12161
12162   arg1 = (Dali::Matrix3 *)jarg1;
12163   {
12164     try {
12165       (arg1)->SetIdentity();
12166     } catch (std::out_of_range& e) {
12167       {
12168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12169       };
12170     } catch (std::exception& e) {
12171       {
12172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12173       };
12174     } catch (...) {
12175       {
12176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12177       };
12178     }
12179   }
12180 }
12181
12182
12183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12184   void * jresult ;
12185   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12186   float *result = 0 ;
12187
12188   arg1 = (Dali::Matrix3 *)jarg1;
12189   {
12190     try {
12191       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12192     } catch (std::out_of_range& e) {
12193       {
12194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (std::exception& e) {
12197       {
12198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (...) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12203       };
12204     }
12205   }
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12212   unsigned int jresult ;
12213   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12214   bool result;
12215
12216   arg1 = (Dali::Matrix3 *)jarg1;
12217   {
12218     try {
12219       result = (bool)(arg1)->Invert();
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (...) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12231       };
12232     }
12233   }
12234   jresult = result;
12235   return jresult;
12236 }
12237
12238
12239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12240   unsigned int jresult ;
12241   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12242   bool result;
12243
12244   arg1 = (Dali::Matrix3 *)jarg1;
12245   {
12246     try {
12247       result = (bool)(arg1)->Transpose();
12248     } catch (std::out_of_range& e) {
12249       {
12250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12251       };
12252     } catch (std::exception& e) {
12253       {
12254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (...) {
12257       {
12258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12259       };
12260     }
12261   }
12262   jresult = result;
12263   return jresult;
12264 }
12265
12266
12267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12268   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12269   float arg2 ;
12270
12271   arg1 = (Dali::Matrix3 *)jarg1;
12272   arg2 = (float)jarg2;
12273   {
12274     try {
12275       (arg1)->Scale(arg2);
12276     } catch (std::out_of_range& e) {
12277       {
12278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12279       };
12280     } catch (std::exception& e) {
12281       {
12282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12283       };
12284     } catch (...) {
12285       {
12286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12287       };
12288     }
12289   }
12290 }
12291
12292
12293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12294   float jresult ;
12295   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12296   float result;
12297
12298   arg1 = (Dali::Matrix3 *)jarg1;
12299   {
12300     try {
12301       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12302     } catch (std::out_of_range& e) {
12303       {
12304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12305       };
12306     } catch (std::exception& e) {
12307       {
12308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12309       };
12310     } catch (...) {
12311       {
12312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12313       };
12314     }
12315   }
12316   jresult = result;
12317   return jresult;
12318 }
12319
12320
12321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12322   unsigned int jresult ;
12323   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12324   bool result;
12325
12326   arg1 = (Dali::Matrix3 *)jarg1;
12327   {
12328     try {
12329       result = (bool)(arg1)->ScaledInverseTranspose();
12330     } catch (std::out_of_range& e) {
12331       {
12332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12333       };
12334     } catch (std::exception& e) {
12335       {
12336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12337       };
12338     } catch (...) {
12339       {
12340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12341       };
12342     }
12343   }
12344   jresult = result;
12345   return jresult;
12346 }
12347
12348
12349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12350   Dali::Matrix3 *arg1 = 0 ;
12351   Dali::Matrix3 *arg2 = 0 ;
12352   Dali::Matrix3 *arg3 = 0 ;
12353
12354   arg1 = (Dali::Matrix3 *)jarg1;
12355   if (!arg1) {
12356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12357     return ;
12358   }
12359   arg2 = (Dali::Matrix3 *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12362     return ;
12363   }
12364   arg3 = (Dali::Matrix3 *)jarg3;
12365   if (!arg3) {
12366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12367     return ;
12368   }
12369   {
12370     try {
12371       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12372     } catch (std::out_of_range& e) {
12373       {
12374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12375       };
12376     } catch (std::exception& e) {
12377       {
12378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12383       };
12384     }
12385   }
12386 }
12387
12388
12389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12390   float jresult ;
12391   float arg1 ;
12392   float arg2 ;
12393   float result;
12394
12395   arg1 = (float)jarg1;
12396   arg2 = (float)jarg2;
12397   {
12398     try {
12399       result = (float)Dali::Random::Range(arg1,arg2);
12400     } catch (std::out_of_range& e) {
12401       {
12402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12403       };
12404     } catch (std::exception& e) {
12405       {
12406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12407       };
12408     } catch (...) {
12409       {
12410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12411       };
12412     }
12413   }
12414   jresult = result;
12415   return jresult;
12416 }
12417
12418
12419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12420   void * jresult ;
12421   Dali::Vector4 result;
12422
12423   {
12424     try {
12425       result = Dali::Random::Axis();
12426     } catch (std::out_of_range& e) {
12427       {
12428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12429       };
12430     } catch (std::exception& e) {
12431       {
12432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12433       };
12434     } catch (...) {
12435       {
12436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12437       };
12438     }
12439   }
12440   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12441   return jresult;
12442 }
12443
12444
12445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12446   void * jresult ;
12447   Dali::AngleAxis *result = 0 ;
12448
12449   {
12450     try {
12451       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12452     } catch (std::out_of_range& e) {
12453       {
12454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12455       };
12456     } catch (std::exception& e) {
12457       {
12458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12463       };
12464     }
12465   }
12466   jresult = (void *)result;
12467   return jresult;
12468 }
12469
12470
12471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12472   void * jresult ;
12473   Dali::Radian arg1 ;
12474   Dali::Vector3 *arg2 = 0 ;
12475   Dali::Radian *argp1 ;
12476   Dali::AngleAxis *result = 0 ;
12477
12478   argp1 = (Dali::Radian *)jarg1;
12479   if (!argp1) {
12480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12481     return 0;
12482   }
12483   arg1 = *argp1;
12484   arg2 = (Dali::Vector3 *)jarg2;
12485   if (!arg2) {
12486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12487     return 0;
12488   }
12489   {
12490     try {
12491       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12492     } catch (std::out_of_range& e) {
12493       {
12494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12495       };
12496     } catch (std::exception& e) {
12497       {
12498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12499       };
12500     } catch (...) {
12501       {
12502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12503       };
12504     }
12505   }
12506   jresult = (void *)result;
12507   return jresult;
12508 }
12509
12510
12511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12512   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12513   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12514
12515   arg1 = (Dali::AngleAxis *)jarg1;
12516   arg2 = (Dali::Radian *)jarg2;
12517   if (arg1) (arg1)->angle = *arg2;
12518 }
12519
12520
12521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12522   void * jresult ;
12523   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12524   Dali::Radian *result = 0 ;
12525
12526   arg1 = (Dali::AngleAxis *)jarg1;
12527   result = (Dali::Radian *)& ((arg1)->angle);
12528   jresult = (void *)result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12534   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12535   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12536
12537   arg1 = (Dali::AngleAxis *)jarg1;
12538   arg2 = (Dali::Vector3 *)jarg2;
12539   if (arg1) (arg1)->axis = *arg2;
12540 }
12541
12542
12543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12544   void * jresult ;
12545   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12546   Dali::Vector3 *result = 0 ;
12547
12548   arg1 = (Dali::AngleAxis *)jarg1;
12549   result = (Dali::Vector3 *)& ((arg1)->axis);
12550   jresult = (void *)result;
12551   return jresult;
12552 }
12553
12554
12555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12556   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12557
12558   arg1 = (Dali::AngleAxis *)jarg1;
12559   {
12560     try {
12561       delete arg1;
12562     } catch (std::out_of_range& e) {
12563       {
12564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12565       };
12566     } catch (std::exception& e) {
12567       {
12568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12573       };
12574     }
12575   }
12576 }
12577
12578
12579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12580   unsigned int jresult ;
12581   Dali::AngleAxis *arg1 = 0 ;
12582   Dali::AngleAxis *arg2 = 0 ;
12583   bool result;
12584
12585   arg1 = (Dali::AngleAxis *)jarg1;
12586   if (!arg1) {
12587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12588     return 0;
12589   }
12590   arg2 = (Dali::AngleAxis *)jarg2;
12591   if (!arg2) {
12592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12593     return 0;
12594   }
12595   {
12596     try {
12597       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12598     } catch (std::out_of_range& e) {
12599       {
12600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12601       };
12602     } catch (std::exception& e) {
12603       {
12604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12605       };
12606     } catch (...) {
12607       {
12608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12609       };
12610     }
12611   }
12612   jresult = result;
12613   return jresult;
12614 }
12615
12616
12617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12618   unsigned int jresult ;
12619   unsigned int arg1 ;
12620   unsigned int result;
12621
12622   arg1 = (unsigned int)jarg1;
12623   {
12624     try {
12625       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12626     } catch (std::out_of_range& e) {
12627       {
12628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12629       };
12630     } catch (std::exception& e) {
12631       {
12632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12633       };
12634     } catch (...) {
12635       {
12636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12637       };
12638     }
12639   }
12640   jresult = result;
12641   return jresult;
12642 }
12643
12644
12645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12646   unsigned int jresult ;
12647   unsigned int arg1 ;
12648   bool result;
12649
12650   arg1 = (unsigned int)jarg1;
12651   {
12652     try {
12653       result = (bool)Dali::IsPowerOfTwo(arg1);
12654     } catch (std::out_of_range& e) {
12655       {
12656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12657       };
12658     } catch (std::exception& e) {
12659       {
12660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12661       };
12662     } catch (...) {
12663       {
12664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12665       };
12666     }
12667   }
12668   jresult = result;
12669   return jresult;
12670 }
12671
12672
12673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12674   float jresult ;
12675   float arg1 ;
12676   float arg2 ;
12677   float result;
12678
12679   arg1 = (float)jarg1;
12680   arg2 = (float)jarg2;
12681   {
12682     try {
12683       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12684     } catch (std::out_of_range& e) {
12685       {
12686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12687       };
12688     } catch (std::exception& e) {
12689       {
12690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12691       };
12692     } catch (...) {
12693       {
12694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12695       };
12696     }
12697   }
12698   jresult = result;
12699   return jresult;
12700 }
12701
12702
12703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12704   unsigned int jresult ;
12705   float arg1 ;
12706   bool result;
12707
12708   arg1 = (float)jarg1;
12709   {
12710     try {
12711       result = (bool)Dali::EqualsZero(arg1);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12719       };
12720     } catch (...) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12723       };
12724     }
12725   }
12726   jresult = result;
12727   return jresult;
12728 }
12729
12730
12731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12732   unsigned int jresult ;
12733   float arg1 ;
12734   float arg2 ;
12735   bool result;
12736
12737   arg1 = (float)jarg1;
12738   arg2 = (float)jarg2;
12739   {
12740     try {
12741       result = (bool)Dali::Equals(arg1,arg2);
12742     } catch (std::out_of_range& e) {
12743       {
12744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12745       };
12746     } catch (std::exception& e) {
12747       {
12748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12749       };
12750     } catch (...) {
12751       {
12752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12753       };
12754     }
12755   }
12756   jresult = result;
12757   return jresult;
12758 }
12759
12760
12761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12762   unsigned int jresult ;
12763   float arg1 ;
12764   float arg2 ;
12765   float arg3 ;
12766   bool result;
12767
12768   arg1 = (float)jarg1;
12769   arg2 = (float)jarg2;
12770   arg3 = (float)jarg3;
12771   {
12772     try {
12773       result = (bool)Dali::Equals(arg1,arg2,arg3);
12774     } catch (std::out_of_range& e) {
12775       {
12776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (std::exception& e) {
12779       {
12780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788   jresult = result;
12789   return jresult;
12790 }
12791
12792
12793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12794   float jresult ;
12795   float arg1 ;
12796   int arg2 ;
12797   float result;
12798
12799   arg1 = (float)jarg1;
12800   arg2 = (int)jarg2;
12801   {
12802     try {
12803       result = (float)Dali::Round(arg1,arg2);
12804     } catch (std::out_of_range& e) {
12805       {
12806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12807       };
12808     } catch (std::exception& e) {
12809       {
12810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (...) {
12813       {
12814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12815       };
12816     }
12817   }
12818   jresult = result;
12819   return jresult;
12820 }
12821
12822
12823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12824   float jresult ;
12825   float arg1 ;
12826   float arg2 ;
12827   float arg3 ;
12828   float result;
12829
12830   arg1 = (float)jarg1;
12831   arg2 = (float)jarg2;
12832   arg3 = (float)jarg3;
12833   {
12834     try {
12835       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12836     } catch (std::out_of_range& e) {
12837       {
12838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12839       };
12840     } catch (std::exception& e) {
12841       {
12842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12847       };
12848     }
12849   }
12850   jresult = result;
12851   return jresult;
12852 }
12853
12854
12855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12856   float jresult ;
12857   float arg1 ;
12858   float arg2 ;
12859   float arg3 ;
12860   float arg4 ;
12861   float result;
12862
12863   arg1 = (float)jarg1;
12864   arg2 = (float)jarg2;
12865   arg3 = (float)jarg3;
12866   arg4 = (float)jarg4;
12867   {
12868     try {
12869       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12870     } catch (std::out_of_range& e) {
12871       {
12872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12873       };
12874     } catch (std::exception& e) {
12875       {
12876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12877       };
12878     } catch (...) {
12879       {
12880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12881       };
12882     }
12883   }
12884   jresult = result;
12885   return jresult;
12886 }
12887
12888
12889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12890   int jresult ;
12891   int result;
12892
12893   result = (int)(int)Dali::Property::INVALID_INDEX;
12894   jresult = result;
12895   return jresult;
12896 }
12897
12898
12899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12900   int jresult ;
12901   int result;
12902
12903   result = (int)(int)Dali::Property::INVALID_KEY;
12904   jresult = result;
12905   return jresult;
12906 }
12907
12908
12909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12910   int jresult ;
12911   int result;
12912
12913   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12914   jresult = result;
12915   return jresult;
12916 }
12917
12918
12919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12920   void * jresult ;
12921   Dali::Handle *arg1 = 0 ;
12922   Dali::Property::Index arg2 ;
12923   Dali::Property *result = 0 ;
12924
12925   arg1 = (Dali::Handle *)jarg1;
12926   if (!arg1) {
12927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12928     return 0;
12929   }
12930   arg2 = (Dali::Property::Index)jarg2;
12931   {
12932     try {
12933       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12934     } catch (std::out_of_range& e) {
12935       {
12936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (std::exception& e) {
12939       {
12940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948   jresult = (void *)result;
12949   return jresult;
12950 }
12951
12952
12953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12954   void * jresult ;
12955   Dali::Handle *arg1 = 0 ;
12956   Dali::Property::Index arg2 ;
12957   int arg3 ;
12958   Dali::Property *result = 0 ;
12959
12960   arg1 = (Dali::Handle *)jarg1;
12961   if (!arg1) {
12962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12963     return 0;
12964   }
12965   arg2 = (Dali::Property::Index)jarg2;
12966   arg3 = (int)jarg3;
12967   {
12968     try {
12969       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12970     } catch (std::out_of_range& e) {
12971       {
12972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12973       };
12974     } catch (std::exception& e) {
12975       {
12976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12977       };
12978     } catch (...) {
12979       {
12980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12981       };
12982     }
12983   }
12984   jresult = (void *)result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12990   void * jresult ;
12991   Dali::Handle *arg1 = 0 ;
12992   std::string *arg2 = 0 ;
12993   Dali::Property *result = 0 ;
12994
12995   arg1 = (Dali::Handle *)jarg1;
12996   if (!arg1) {
12997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12998     return 0;
12999   }
13000   if (!jarg2) {
13001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13002     return 0;
13003   }
13004   std::string arg2_str(jarg2);
13005   arg2 = &arg2_str;
13006   {
13007     try {
13008       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13009     } catch (std::out_of_range& e) {
13010       {
13011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13012       };
13013     } catch (std::exception& e) {
13014       {
13015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13016       };
13017     } catch (...) {
13018       {
13019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13020       };
13021     }
13022   }
13023   jresult = (void *)result;
13024
13025   //argout typemap for const std::string&
13026
13027   return jresult;
13028 }
13029
13030
13031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13032   void * jresult ;
13033   Dali::Handle *arg1 = 0 ;
13034   std::string *arg2 = 0 ;
13035   int arg3 ;
13036   Dali::Property *result = 0 ;
13037
13038   arg1 = (Dali::Handle *)jarg1;
13039   if (!arg1) {
13040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13041     return 0;
13042   }
13043   if (!jarg2) {
13044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13045     return 0;
13046   }
13047   std::string arg2_str(jarg2);
13048   arg2 = &arg2_str;
13049   arg3 = (int)jarg3;
13050   {
13051     try {
13052       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13053     } catch (std::out_of_range& e) {
13054       {
13055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13056       };
13057     } catch (std::exception& e) {
13058       {
13059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13060       };
13061     } catch (...) {
13062       {
13063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13064       };
13065     }
13066   }
13067   jresult = (void *)result;
13068
13069   //argout typemap for const std::string&
13070
13071   return jresult;
13072 }
13073
13074
13075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13076   Dali::Property *arg1 = (Dali::Property *) 0 ;
13077
13078   arg1 = (Dali::Property *)jarg1;
13079   {
13080     try {
13081       delete arg1;
13082     } catch (std::out_of_range& e) {
13083       {
13084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13085       };
13086     } catch (std::exception& e) {
13087       {
13088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13089       };
13090     } catch (...) {
13091       {
13092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13093       };
13094     }
13095   }
13096 }
13097
13098
13099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13100   Dali::Property *arg1 = (Dali::Property *) 0 ;
13101   Dali::Handle *arg2 = 0 ;
13102
13103   arg1 = (Dali::Property *)jarg1;
13104   arg2 = (Dali::Handle *)jarg2;
13105   if (!arg2) {
13106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13107     return ;
13108   }
13109   if (arg1) (arg1)->object = *arg2;
13110 }
13111
13112
13113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13114   void * jresult ;
13115   Dali::Property *arg1 = (Dali::Property *) 0 ;
13116   Dali::Handle *result = 0 ;
13117
13118   arg1 = (Dali::Property *)jarg1;
13119   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13120   jresult = (void *)result;
13121   return jresult;
13122 }
13123
13124
13125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13126   Dali::Property *arg1 = (Dali::Property *) 0 ;
13127   Dali::Property::Index arg2 ;
13128
13129   arg1 = (Dali::Property *)jarg1;
13130   arg2 = (Dali::Property::Index)jarg2;
13131   if (arg1) (arg1)->propertyIndex = arg2;
13132 }
13133
13134
13135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13136   int jresult ;
13137   Dali::Property *arg1 = (Dali::Property *) 0 ;
13138   Dali::Property::Index result;
13139
13140   arg1 = (Dali::Property *)jarg1;
13141   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13142   jresult = result;
13143   return jresult;
13144 }
13145
13146
13147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13148   Dali::Property *arg1 = (Dali::Property *) 0 ;
13149   int arg2 ;
13150
13151   arg1 = (Dali::Property *)jarg1;
13152   arg2 = (int)jarg2;
13153   if (arg1) (arg1)->componentIndex = arg2;
13154 }
13155
13156
13157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13158   int jresult ;
13159   Dali::Property *arg1 = (Dali::Property *) 0 ;
13160   int result;
13161
13162   arg1 = (Dali::Property *)jarg1;
13163   result = (int) ((arg1)->componentIndex);
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13170   void * jresult ;
13171   Dali::Property::Array *result = 0 ;
13172
13173   {
13174     try {
13175       result = (Dali::Property::Array *)new Dali::Property::Array();
13176     } catch (std::out_of_range& e) {
13177       {
13178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13179       };
13180     } catch (std::exception& e) {
13181       {
13182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13183       };
13184     } catch (...) {
13185       {
13186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13187       };
13188     }
13189   }
13190   jresult = (void *)result;
13191   return jresult;
13192 }
13193
13194
13195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13196   void * jresult ;
13197   Dali::Property::Array *arg1 = 0 ;
13198   Dali::Property::Array *result = 0 ;
13199
13200   arg1 = (Dali::Property::Array *)jarg1;
13201   if (!arg1) {
13202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13203     return 0;
13204   }
13205   {
13206     try {
13207       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13208     } catch (std::out_of_range& e) {
13209       {
13210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13211       };
13212     } catch (std::exception& e) {
13213       {
13214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13215       };
13216     } catch (...) {
13217       {
13218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13219       };
13220     }
13221   }
13222   jresult = (void *)result;
13223   return jresult;
13224 }
13225
13226
13227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13228   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13229
13230   arg1 = (Dali::Property::Array *)jarg1;
13231   {
13232     try {
13233       delete arg1;
13234     } catch (std::out_of_range& e) {
13235       {
13236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13237       };
13238     } catch (std::exception& e) {
13239       {
13240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13241       };
13242     } catch (...) {
13243       {
13244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13245       };
13246     }
13247   }
13248 }
13249
13250
13251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13252   unsigned long jresult ;
13253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13254   Dali::Property::Array::SizeType result;
13255
13256   arg1 = (Dali::Property::Array *)jarg1;
13257   {
13258     try {
13259       result = ((Dali::Property::Array const *)arg1)->Size();
13260     } catch (std::out_of_range& e) {
13261       {
13262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13263       };
13264     } catch (std::exception& e) {
13265       {
13266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13267       };
13268     } catch (...) {
13269       {
13270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13271       };
13272     }
13273   }
13274   jresult = (unsigned long)result;
13275   return jresult;
13276 }
13277
13278
13279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13280   unsigned long jresult ;
13281   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13282   Dali::Property::Array::SizeType result;
13283
13284   arg1 = (Dali::Property::Array *)jarg1;
13285   {
13286     try {
13287       result = ((Dali::Property::Array const *)arg1)->Count();
13288     } catch (std::out_of_range& e) {
13289       {
13290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (std::exception& e) {
13293       {
13294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13295       };
13296     } catch (...) {
13297       {
13298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13299       };
13300     }
13301   }
13302   jresult = (unsigned long)result;
13303   return jresult;
13304 }
13305
13306
13307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13308   unsigned int jresult ;
13309   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13310   bool result;
13311
13312   arg1 = (Dali::Property::Array *)jarg1;
13313   {
13314     try {
13315       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13316     } catch (std::out_of_range& e) {
13317       {
13318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13319       };
13320     } catch (std::exception& e) {
13321       {
13322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13323       };
13324     } catch (...) {
13325       {
13326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13327       };
13328     }
13329   }
13330   jresult = result;
13331   return jresult;
13332 }
13333
13334
13335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13336   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13337
13338   arg1 = (Dali::Property::Array *)jarg1;
13339   {
13340     try {
13341       (arg1)->Clear();
13342     } catch (std::out_of_range& e) {
13343       {
13344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (std::exception& e) {
13347       {
13348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (...) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13353       };
13354     }
13355   }
13356 }
13357
13358
13359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13361   Dali::Property::Array::SizeType arg2 ;
13362
13363   arg1 = (Dali::Property::Array *)jarg1;
13364   arg2 = (Dali::Property::Array::SizeType)jarg2;
13365   {
13366     try {
13367       (arg1)->Reserve(arg2);
13368     } catch (std::out_of_range& e) {
13369       {
13370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13371       };
13372     } catch (std::exception& e) {
13373       {
13374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (...) {
13377       {
13378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13379       };
13380     }
13381   }
13382 }
13383
13384
13385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13386   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13387   Dali::Property::Array::SizeType arg2 ;
13388
13389   arg1 = (Dali::Property::Array *)jarg1;
13390   arg2 = (Dali::Property::Array::SizeType)jarg2;
13391   {
13392     try {
13393       (arg1)->Resize(arg2);
13394     } catch (std::out_of_range& e) {
13395       {
13396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13397       };
13398     } catch (std::exception& e) {
13399       {
13400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13401       };
13402     } catch (...) {
13403       {
13404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13405       };
13406     }
13407   }
13408 }
13409
13410
13411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13412   unsigned long jresult ;
13413   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13414   Dali::Property::Array::SizeType result;
13415
13416   arg1 = (Dali::Property::Array *)jarg1;
13417   {
13418     try {
13419       result = (arg1)->Capacity();
13420     } catch (std::out_of_range& e) {
13421       {
13422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13423       };
13424     } catch (std::exception& e) {
13425       {
13426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13427       };
13428     } catch (...) {
13429       {
13430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13431       };
13432     }
13433   }
13434   jresult = (unsigned long)result;
13435   return jresult;
13436 }
13437
13438
13439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13440   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13441   Dali::Property::Value *arg2 = 0 ;
13442
13443   arg1 = (Dali::Property::Array *)jarg1;
13444   arg2 = (Dali::Property::Value *)jarg2;
13445   if (!arg2) {
13446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13447     return ;
13448   }
13449   {
13450     try {
13451       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13452     } catch (std::out_of_range& e) {
13453       {
13454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13455       };
13456     } catch (std::exception& e) {
13457       {
13458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13463       };
13464     }
13465   }
13466 }
13467
13468
13469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13470   void * jresult ;
13471   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13472   Dali::Property::Value *arg2 = 0 ;
13473   Dali::Property::Array *result = 0 ;
13474
13475   arg1 = (Dali::Property::Array *)jarg1;
13476   arg2 = (Dali::Property::Value *)jarg2;
13477   if (!arg2) {
13478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13479     return 0;
13480   }
13481   {
13482     try {
13483       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13484     } catch (std::out_of_range& e) {
13485       {
13486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13487       };
13488     } catch (std::exception& e) {
13489       {
13490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (...) {
13493       {
13494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13495       };
13496     }
13497   }
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13504   void * jresult ;
13505   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13506   Dali::Property::Array::SizeType arg2 ;
13507   Dali::Property::Value *result = 0 ;
13508
13509   arg1 = (Dali::Property::Array *)jarg1;
13510   arg2 = (Dali::Property::Array::SizeType)jarg2;
13511   {
13512     try {
13513       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13514     } catch (std::out_of_range& e) {
13515       {
13516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13517       };
13518     } catch (std::exception& e) {
13519       {
13520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13521       };
13522     } catch (...) {
13523       {
13524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13525       };
13526     }
13527   }
13528   jresult = (void *)result;
13529   return jresult;
13530 }
13531
13532
13533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13534   void * jresult ;
13535   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13536   Dali::Property::Array::SizeType arg2 ;
13537   Dali::Property::Value *result = 0 ;
13538
13539   arg1 = (Dali::Property::Array *)jarg1;
13540   arg2 = (Dali::Property::Array::SizeType)jarg2;
13541   {
13542     try {
13543       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13544     } catch (std::out_of_range& e) {
13545       {
13546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13547       };
13548     } catch (std::exception& e) {
13549       {
13550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13551       };
13552     } catch (...) {
13553       {
13554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13555       };
13556     }
13557   }
13558   jresult = (void *)result;
13559   return jresult;
13560 }
13561
13562
13563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13564   void * jresult ;
13565   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13566   Dali::Property::Array *arg2 = 0 ;
13567   Dali::Property::Array *result = 0 ;
13568
13569   arg1 = (Dali::Property::Array *)jarg1;
13570   arg2 = (Dali::Property::Array *)jarg2;
13571   if (!arg2) {
13572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13573     return 0;
13574   }
13575   {
13576     try {
13577       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13578     } catch (std::out_of_range& e) {
13579       {
13580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (std::exception& e) {
13583       {
13584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13598   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13599   enum Dali::Property::Key::Type arg2 ;
13600
13601   arg1 = (Dali::Property::Key *)jarg1;
13602   arg2 = (enum Dali::Property::Key::Type)jarg2;
13603   if (arg1) (arg1)->type = arg2;
13604 }
13605
13606
13607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13608   int jresult ;
13609   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13610   enum Dali::Property::Key::Type result;
13611
13612   arg1 = (Dali::Property::Key *)jarg1;
13613   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13614   jresult = (int)result;
13615   return jresult;
13616 }
13617
13618
13619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13620   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13621   Dali::Property::Index arg2 ;
13622
13623   arg1 = (Dali::Property::Key *)jarg1;
13624   arg2 = (Dali::Property::Index)jarg2;
13625   if (arg1) (arg1)->indexKey = arg2;
13626 }
13627
13628
13629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13630   int jresult ;
13631   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13632   Dali::Property::Index result;
13633
13634   arg1 = (Dali::Property::Key *)jarg1;
13635   result = (Dali::Property::Index) ((arg1)->indexKey);
13636   jresult = result;
13637   return jresult;
13638 }
13639
13640
13641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13642   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13643   std::string *arg2 = 0 ;
13644
13645   arg1 = (Dali::Property::Key *)jarg1;
13646   if (!jarg2) {
13647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13648     return ;
13649   }
13650   std::string arg2_str(jarg2);
13651   arg2 = &arg2_str;
13652   if (arg1) (arg1)->stringKey = *arg2;
13653
13654   //argout typemap for const std::string&
13655
13656 }
13657
13658
13659 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13660   char * jresult ;
13661   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13662   std::string *result = 0 ;
13663
13664   arg1 = (Dali::Property::Key *)jarg1;
13665   result = (std::string *) & ((arg1)->stringKey);
13666   jresult = SWIG_csharp_string_callback(result->c_str());
13667   return jresult;
13668 }
13669
13670
13671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13672   void * jresult ;
13673   std::string *arg1 = 0 ;
13674   Dali::Property::Key *result = 0 ;
13675
13676   if (!jarg1) {
13677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13678     return 0;
13679   }
13680   std::string arg1_str(jarg1);
13681   arg1 = &arg1_str;
13682   {
13683     try {
13684       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13685     } catch (std::out_of_range& e) {
13686       {
13687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13688       };
13689     } catch (std::exception& e) {
13690       {
13691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13692       };
13693     } catch (...) {
13694       {
13695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13696       };
13697     }
13698   }
13699   jresult = (void *)result;
13700
13701   //argout typemap for const std::string&
13702
13703   return jresult;
13704 }
13705
13706
13707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13708   void * jresult ;
13709   Dali::Property::Index arg1 ;
13710   Dali::Property::Key *result = 0 ;
13711
13712   arg1 = (Dali::Property::Index)jarg1;
13713   {
13714     try {
13715       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13716     } catch (std::out_of_range& e) {
13717       {
13718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13719       };
13720     } catch (std::exception& e) {
13721       {
13722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13723       };
13724     } catch (...) {
13725       {
13726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13727       };
13728     }
13729   }
13730   jresult = (void *)result;
13731   return jresult;
13732 }
13733
13734
13735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13736   unsigned int jresult ;
13737   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13738   std::string *arg2 = 0 ;
13739   bool result;
13740
13741   arg1 = (Dali::Property::Key *)jarg1;
13742   if (!jarg2) {
13743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13744     return 0;
13745   }
13746   std::string arg2_str(jarg2);
13747   arg2 = &arg2_str;
13748   {
13749     try {
13750       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13758       };
13759     } catch (...) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13762       };
13763     }
13764   }
13765   jresult = result;
13766
13767   //argout typemap for const std::string&
13768
13769   return jresult;
13770 }
13771
13772
13773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13774   unsigned int jresult ;
13775   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13776   Dali::Property::Index arg2 ;
13777   bool result;
13778
13779   arg1 = (Dali::Property::Key *)jarg1;
13780   arg2 = (Dali::Property::Index)jarg2;
13781   {
13782     try {
13783       result = (bool)(arg1)->operator ==(arg2);
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (...) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13795       };
13796     }
13797   }
13798   jresult = result;
13799   return jresult;
13800 }
13801
13802
13803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13804   unsigned int jresult ;
13805   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13806   Dali::Property::Key *arg2 = 0 ;
13807   bool result;
13808
13809   arg1 = (Dali::Property::Key *)jarg1;
13810   arg2 = (Dali::Property::Key *)jarg2;
13811   if (!arg2) {
13812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13813     return 0;
13814   }
13815   {
13816     try {
13817       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13818     } catch (std::out_of_range& e) {
13819       {
13820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (std::exception& e) {
13823       {
13824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832   jresult = result;
13833   return jresult;
13834 }
13835
13836
13837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13838   unsigned int jresult ;
13839   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13840   std::string *arg2 = 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Property::Key *)jarg1;
13844   if (!jarg2) {
13845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13846     return 0;
13847   }
13848   std::string arg2_str(jarg2);
13849   arg2 = &arg2_str;
13850   {
13851     try {
13852       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13853     } catch (std::out_of_range& e) {
13854       {
13855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (std::exception& e) {
13858       {
13859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13860       };
13861     } catch (...) {
13862       {
13863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13864       };
13865     }
13866   }
13867   jresult = result;
13868
13869   //argout typemap for const std::string&
13870
13871   return jresult;
13872 }
13873
13874
13875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13876   unsigned int jresult ;
13877   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13878   Dali::Property::Index arg2 ;
13879   bool result;
13880
13881   arg1 = (Dali::Property::Key *)jarg1;
13882   arg2 = (Dali::Property::Index)jarg2;
13883   {
13884     try {
13885       result = (bool)(arg1)->operator !=(arg2);
13886     } catch (std::out_of_range& e) {
13887       {
13888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13889       };
13890     } catch (std::exception& e) {
13891       {
13892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13893       };
13894     } catch (...) {
13895       {
13896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13897       };
13898     }
13899   }
13900   jresult = result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13906   unsigned int jresult ;
13907   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13908   Dali::Property::Key *arg2 = 0 ;
13909   bool result;
13910
13911   arg1 = (Dali::Property::Key *)jarg1;
13912   arg2 = (Dali::Property::Key *)jarg2;
13913   if (!arg2) {
13914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13915     return 0;
13916   }
13917   {
13918     try {
13919       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13920     } catch (std::out_of_range& e) {
13921       {
13922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13923       };
13924     } catch (std::exception& e) {
13925       {
13926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13927       };
13928     } catch (...) {
13929       {
13930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13931       };
13932     }
13933   }
13934   jresult = result;
13935   return jresult;
13936 }
13937
13938
13939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13940   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13941
13942   arg1 = (Dali::Property::Key *)jarg1;
13943   {
13944     try {
13945       delete arg1;
13946     } catch (std::out_of_range& e) {
13947       {
13948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13949       };
13950     } catch (std::exception& e) {
13951       {
13952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13953       };
13954     } catch (...) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13957       };
13958     }
13959   }
13960 }
13961
13962
13963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13964   void * jresult ;
13965   Dali::Property::Map *result = 0 ;
13966
13967   {
13968     try {
13969       result = (Dali::Property::Map *)new Dali::Property::Map();
13970     } catch (std::out_of_range& e) {
13971       {
13972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13973       };
13974     } catch (std::exception& e) {
13975       {
13976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13977       };
13978     } catch (...) {
13979       {
13980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13981       };
13982     }
13983   }
13984   jresult = (void *)result;
13985   return jresult;
13986 }
13987
13988
13989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13990   void * jresult ;
13991   Dali::Property::Map *arg1 = 0 ;
13992   Dali::Property::Map *result = 0 ;
13993
13994   arg1 = (Dali::Property::Map *)jarg1;
13995   if (!arg1) {
13996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13997     return 0;
13998   }
13999   {
14000     try {
14001       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14002     } catch (std::out_of_range& e) {
14003       {
14004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14005       };
14006     } catch (std::exception& e) {
14007       {
14008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14009       };
14010     } catch (...) {
14011       {
14012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14013       };
14014     }
14015   }
14016   jresult = (void *)result;
14017   return jresult;
14018 }
14019
14020
14021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14022   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14023
14024   arg1 = (Dali::Property::Map *)jarg1;
14025   {
14026     try {
14027       delete arg1;
14028     } catch (std::out_of_range& e) {
14029       {
14030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14031       };
14032     } catch (std::exception& e) {
14033       {
14034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14039       };
14040     }
14041   }
14042 }
14043
14044
14045 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14046   unsigned long jresult ;
14047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14048   Dali::Property::Map::SizeType result;
14049
14050   arg1 = (Dali::Property::Map *)jarg1;
14051   {
14052     try {
14053       result = ((Dali::Property::Map const *)arg1)->Count();
14054     } catch (std::out_of_range& e) {
14055       {
14056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (std::exception& e) {
14059       {
14060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (...) {
14063       {
14064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14065       };
14066     }
14067   }
14068   jresult = (unsigned long)result;
14069   return jresult;
14070 }
14071
14072
14073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14074   unsigned int jresult ;
14075   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14076   bool result;
14077
14078   arg1 = (Dali::Property::Map *)jarg1;
14079   {
14080     try {
14081       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14082     } catch (std::out_of_range& e) {
14083       {
14084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14085       };
14086     } catch (std::exception& e) {
14087       {
14088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (...) {
14091       {
14092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14093       };
14094     }
14095   }
14096   jresult = result;
14097   return jresult;
14098 }
14099
14100
14101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14102   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14103   char *arg2 = (char *) 0 ;
14104   Dali::Property::Value *arg3 = 0 ;
14105
14106   arg1 = (Dali::Property::Map *)jarg1;
14107   arg2 = (char *)jarg2;
14108   arg3 = (Dali::Property::Value *)jarg3;
14109   if (!arg3) {
14110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14111     return ;
14112   }
14113   {
14114     try {
14115       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14116     } catch (std::out_of_range& e) {
14117       {
14118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14119       };
14120     } catch (std::exception& e) {
14121       {
14122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14123       };
14124     } catch (...) {
14125       {
14126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14127       };
14128     }
14129   }
14130 }
14131
14132
14133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14134   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14135   Dali::Property::Index arg2 ;
14136   Dali::Property::Value *arg3 = 0 ;
14137
14138   arg1 = (Dali::Property::Map *)jarg1;
14139   arg2 = (Dali::Property::Index)jarg2;
14140   arg3 = (Dali::Property::Value *)jarg3;
14141   if (!arg3) {
14142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14143     return ;
14144   }
14145   {
14146     try {
14147       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14148     } catch (std::out_of_range& e) {
14149       {
14150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14151       };
14152     } catch (std::exception& e) {
14153       {
14154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14155       };
14156     } catch (...) {
14157       {
14158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14159       };
14160     }
14161   }
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14166   void * jresult ;
14167   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14168   char *arg2 = (char *) 0 ;
14169   Dali::Property::Value *arg3 = 0 ;
14170   Dali::Property::Map *result = 0 ;
14171
14172   arg1 = (Dali::Property::Map *)jarg1;
14173   arg2 = (char *)jarg2;
14174   arg3 = (Dali::Property::Value *)jarg3;
14175   if (!arg3) {
14176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14177     return 0;
14178   }
14179   {
14180     try {
14181       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14182     } catch (std::out_of_range& e) {
14183       {
14184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14185       };
14186     } catch (std::exception& e) {
14187       {
14188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14189       };
14190     } catch (...) {
14191       {
14192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14193       };
14194     }
14195   }
14196   jresult = (void *)result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14202   void * jresult ;
14203   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14204   Dali::Property::Index arg2 ;
14205   Dali::Property::Value *arg3 = 0 ;
14206   Dali::Property::Map *result = 0 ;
14207
14208   arg1 = (Dali::Property::Map *)jarg1;
14209   arg2 = (Dali::Property::Index)jarg2;
14210   arg3 = (Dali::Property::Value *)jarg3;
14211   if (!arg3) {
14212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14213     return 0;
14214   }
14215   {
14216     try {
14217       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14218     } catch (std::out_of_range& e) {
14219       {
14220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14221       };
14222     } catch (std::exception& e) {
14223       {
14224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14225       };
14226     } catch (...) {
14227       {
14228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14229       };
14230     }
14231   }
14232   jresult = (void *)result;
14233   return jresult;
14234 }
14235
14236
14237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14238   void * jresult ;
14239   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14240   Dali::Property::Map::SizeType arg2 ;
14241   Dali::Property::Value *result = 0 ;
14242
14243   arg1 = (Dali::Property::Map *)jarg1;
14244   arg2 = (Dali::Property::Map::SizeType)jarg2;
14245   {
14246     try {
14247       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14259       };
14260     }
14261   }
14262   jresult = (void *)result;
14263   return jresult;
14264 }
14265
14266
14267 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14268   char * jresult ;
14269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14270   Dali::Property::Map::SizeType arg2 ;
14271   std::string *result = 0 ;
14272
14273   arg1 = (Dali::Property::Map *)jarg1;
14274   arg2 = (Dali::Property::Map::SizeType)jarg2;
14275   {
14276     try {
14277       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14278     } catch (std::out_of_range& e) {
14279       {
14280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14281       };
14282     } catch (std::exception& e) {
14283       {
14284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (...) {
14287       {
14288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14289       };
14290     }
14291   }
14292   jresult = SWIG_csharp_string_callback(result->c_str());
14293   return jresult;
14294 }
14295
14296
14297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14298   void * jresult ;
14299   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14300   Dali::Property::Map::SizeType arg2 ;
14301   SwigValueWrapper< Dali::Property::Key > result;
14302
14303   arg1 = (Dali::Property::Map *)jarg1;
14304   arg2 = (Dali::Property::Map::SizeType)jarg2;
14305   {
14306     try {
14307       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14308     } catch (std::out_of_range& e) {
14309       {
14310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (std::exception& e) {
14313       {
14314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14315       };
14316     } catch (...) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14319       };
14320     }
14321   }
14322   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14328   void * jresult ;
14329   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14330   Dali::Property::Map::SizeType arg2 ;
14331   StringValuePair *result = 0 ;
14332
14333   arg1 = (Dali::Property::Map *)jarg1;
14334   arg2 = (Dali::Property::Map::SizeType)jarg2;
14335   {
14336     try {
14337       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14338     } catch (std::out_of_range& e) {
14339       {
14340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14341       };
14342     } catch (std::exception& e) {
14343       {
14344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14345       };
14346     } catch (...) {
14347       {
14348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14349       };
14350     }
14351   }
14352   jresult = (void *)result;
14353   return jresult;
14354 }
14355
14356
14357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14358   void * jresult ;
14359   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14360   char *arg2 = (char *) 0 ;
14361   Dali::Property::Value *result = 0 ;
14362
14363   arg1 = (Dali::Property::Map *)jarg1;
14364   arg2 = (char *)jarg2;
14365   {
14366     try {
14367       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14368     } catch (std::out_of_range& e) {
14369       {
14370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14371       };
14372     } catch (std::exception& e) {
14373       {
14374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (...) {
14377       {
14378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14379       };
14380     }
14381   }
14382   jresult = (void *)result;
14383   return jresult;
14384 }
14385
14386
14387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14388   void * jresult ;
14389   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14390   Dali::Property::Index arg2 ;
14391   Dali::Property::Value *result = 0 ;
14392
14393   arg1 = (Dali::Property::Map *)jarg1;
14394   arg2 = (Dali::Property::Index)jarg2;
14395   {
14396     try {
14397       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14398     } catch (std::out_of_range& e) {
14399       {
14400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14401       };
14402     } catch (std::exception& e) {
14403       {
14404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14405       };
14406     } catch (...) {
14407       {
14408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14409       };
14410     }
14411   }
14412   jresult = (void *)result;
14413   return jresult;
14414 }
14415
14416
14417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14418   void * jresult ;
14419   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14420   Dali::Property::Index arg2 ;
14421   std::string *arg3 = 0 ;
14422   Dali::Property::Value *result = 0 ;
14423
14424   arg1 = (Dali::Property::Map *)jarg1;
14425   arg2 = (Dali::Property::Index)jarg2;
14426   if (!jarg3) {
14427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14428     return 0;
14429   }
14430   std::string arg3_str(jarg3);
14431   arg3 = &arg3_str;
14432   {
14433     try {
14434       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14435     } catch (std::out_of_range& e) {
14436       {
14437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14438       };
14439     } catch (std::exception& e) {
14440       {
14441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14442       };
14443     } catch (...) {
14444       {
14445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14446       };
14447     }
14448   }
14449   jresult = (void *)result;
14450
14451   //argout typemap for const std::string&
14452
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   std::string *arg2 = 0 ;
14461   Dali::Property::Type arg3 ;
14462   Dali::Property::Value *result = 0 ;
14463
14464   arg1 = (Dali::Property::Map *)jarg1;
14465   if (!jarg2) {
14466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14467     return 0;
14468   }
14469   std::string arg2_str(jarg2);
14470   arg2 = &arg2_str;
14471   arg3 = (Dali::Property::Type)jarg3;
14472   {
14473     try {
14474       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (...) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14486       };
14487     }
14488   }
14489   jresult = (void *)result;
14490
14491   //argout typemap for const std::string&
14492
14493   return jresult;
14494 }
14495
14496
14497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14498   void * jresult ;
14499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14500   Dali::Property::Index arg2 ;
14501   Dali::Property::Type arg3 ;
14502   Dali::Property::Value *result = 0 ;
14503
14504   arg1 = (Dali::Property::Map *)jarg1;
14505   arg2 = (Dali::Property::Index)jarg2;
14506   arg3 = (Dali::Property::Type)jarg3;
14507   {
14508     try {
14509       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14510     } catch (std::out_of_range& e) {
14511       {
14512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14513       };
14514     } catch (std::exception& e) {
14515       {
14516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14517       };
14518     } catch (...) {
14519       {
14520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14521       };
14522     }
14523   }
14524   jresult = (void *)result;
14525   return jresult;
14526 }
14527
14528
14529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14531
14532   arg1 = (Dali::Property::Map *)jarg1;
14533   {
14534     try {
14535       (arg1)->Clear();
14536     } catch (std::out_of_range& e) {
14537       {
14538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14539       };
14540     } catch (std::exception& e) {
14541       {
14542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14543       };
14544     } catch (...) {
14545       {
14546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14547       };
14548     }
14549   }
14550 }
14551
14552
14553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14554   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14555   Dali::Property::Map *arg2 = 0 ;
14556
14557   arg1 = (Dali::Property::Map *)jarg1;
14558   arg2 = (Dali::Property::Map *)jarg2;
14559   if (!arg2) {
14560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14561     return ;
14562   }
14563   {
14564     try {
14565       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14566     } catch (std::out_of_range& e) {
14567       {
14568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14569       };
14570     } catch (std::exception& e) {
14571       {
14572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14573       };
14574     } catch (...) {
14575       {
14576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14577       };
14578     }
14579   }
14580 }
14581
14582
14583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14584   void * jresult ;
14585   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14586   std::string *arg2 = 0 ;
14587   Dali::Property::Value *result = 0 ;
14588
14589   arg1 = (Dali::Property::Map *)jarg1;
14590   if (!jarg2) {
14591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14592     return 0;
14593   }
14594   std::string arg2_str(jarg2);
14595   arg2 = &arg2_str;
14596   {
14597     try {
14598       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14599     } catch (std::out_of_range& e) {
14600       {
14601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14602       };
14603     } catch (std::exception& e) {
14604       {
14605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14606       };
14607     } catch (...) {
14608       {
14609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14610       };
14611     }
14612   }
14613   jresult = (void *)result;
14614
14615   //argout typemap for const std::string&
14616
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property::Value *result = 0 ;
14626
14627   arg1 = (Dali::Property::Map *)jarg1;
14628   arg2 = (Dali::Property::Index)jarg2;
14629   {
14630     try {
14631       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14632     } catch (std::out_of_range& e) {
14633       {
14634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (std::exception& e) {
14637       {
14638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646   jresult = (void *)result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14652   void * jresult ;
14653   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14654   Dali::Property::Map *arg2 = 0 ;
14655   Dali::Property::Map *result = 0 ;
14656
14657   arg1 = (Dali::Property::Map *)jarg1;
14658   arg2 = (Dali::Property::Map *)jarg2;
14659   if (!arg2) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14661     return 0;
14662   }
14663   {
14664     try {
14665       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14677       };
14678     }
14679   }
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14686   void * jresult ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   {
14690     try {
14691       result = (Dali::Property::Value *)new Dali::Property::Value();
14692     } catch (std::out_of_range& e) {
14693       {
14694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14695       };
14696     } catch (std::exception& e) {
14697       {
14698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14699       };
14700     } catch (...) {
14701       {
14702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14703       };
14704     }
14705   }
14706   jresult = (void *)result;
14707   return jresult;
14708 }
14709
14710
14711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14712   void * jresult ;
14713   bool arg1 ;
14714   Dali::Property::Value *result = 0 ;
14715
14716   arg1 = jarg1 ? true : false;
14717   {
14718     try {
14719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14720     } catch (std::out_of_range& e) {
14721       {
14722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (std::exception& e) {
14725       {
14726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14727       };
14728     } catch (...) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14731       };
14732     }
14733   }
14734   jresult = (void *)result;
14735   return jresult;
14736 }
14737
14738
14739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14740   void * jresult ;
14741   int arg1 ;
14742   Dali::Property::Value *result = 0 ;
14743
14744   arg1 = (int)jarg1;
14745   {
14746     try {
14747       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14748     } catch (std::out_of_range& e) {
14749       {
14750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14751       };
14752     } catch (std::exception& e) {
14753       {
14754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14755       };
14756     } catch (...) {
14757       {
14758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14759       };
14760     }
14761   }
14762   jresult = (void *)result;
14763   return jresult;
14764 }
14765
14766
14767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14768   void * jresult ;
14769   float arg1 ;
14770   Dali::Property::Value *result = 0 ;
14771
14772   arg1 = (float)jarg1;
14773   {
14774     try {
14775       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14776     } catch (std::out_of_range& e) {
14777       {
14778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14779       };
14780     } catch (std::exception& e) {
14781       {
14782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14783       };
14784     } catch (...) {
14785       {
14786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14787       };
14788     }
14789   }
14790   jresult = (void *)result;
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14796   void * jresult ;
14797   Dali::Vector2 *arg1 = 0 ;
14798   Dali::Property::Value *result = 0 ;
14799
14800   arg1 = (Dali::Vector2 *)jarg1;
14801   if (!arg1) {
14802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14803     return 0;
14804   }
14805   {
14806     try {
14807       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14808     } catch (std::out_of_range& e) {
14809       {
14810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14811       };
14812     } catch (std::exception& e) {
14813       {
14814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14819       };
14820     }
14821   }
14822   jresult = (void *)result;
14823   return jresult;
14824 }
14825
14826
14827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14828   void * jresult ;
14829   Dali::Vector3 *arg1 = 0 ;
14830   Dali::Property::Value *result = 0 ;
14831
14832   arg1 = (Dali::Vector3 *)jarg1;
14833   if (!arg1) {
14834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14835     return 0;
14836   }
14837   {
14838     try {
14839       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14840     } catch (std::out_of_range& e) {
14841       {
14842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14843       };
14844     } catch (std::exception& e) {
14845       {
14846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14847       };
14848     } catch (...) {
14849       {
14850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14851       };
14852     }
14853   }
14854   jresult = (void *)result;
14855   return jresult;
14856 }
14857
14858
14859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14860   void * jresult ;
14861   Dali::Vector4 *arg1 = 0 ;
14862   Dali::Property::Value *result = 0 ;
14863
14864   arg1 = (Dali::Vector4 *)jarg1;
14865   if (!arg1) {
14866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14867     return 0;
14868   }
14869   {
14870     try {
14871       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14872     } catch (std::out_of_range& e) {
14873       {
14874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14875       };
14876     } catch (std::exception& e) {
14877       {
14878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14879       };
14880     } catch (...) {
14881       {
14882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14883       };
14884     }
14885   }
14886   jresult = (void *)result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14892   void * jresult ;
14893   Dali::Matrix3 *arg1 = 0 ;
14894   Dali::Property::Value *result = 0 ;
14895
14896   arg1 = (Dali::Matrix3 *)jarg1;
14897   if (!arg1) {
14898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14899     return 0;
14900   }
14901   {
14902     try {
14903       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14904     } catch (std::out_of_range& e) {
14905       {
14906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (std::exception& e) {
14909       {
14910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918   jresult = (void *)result;
14919   return jresult;
14920 }
14921
14922
14923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14924   void * jresult ;
14925   Dali::Matrix *arg1 = 0 ;
14926   Dali::Property::Value *result = 0 ;
14927
14928   arg1 = (Dali::Matrix *)jarg1;
14929   if (!arg1) {
14930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14931     return 0;
14932   }
14933   {
14934     try {
14935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14936     } catch (std::out_of_range& e) {
14937       {
14938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14939       };
14940     } catch (std::exception& e) {
14941       {
14942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (...) {
14945       {
14946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14947       };
14948     }
14949   }
14950   jresult = (void *)result;
14951   return jresult;
14952 }
14953
14954
14955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14956   void * jresult ;
14957   Dali::Rect< int > *arg1 = 0 ;
14958   Dali::Property::Value *result = 0 ;
14959
14960   arg1 = (Dali::Rect< int > *)jarg1;
14961   if (!arg1) {
14962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14963     return 0;
14964   }
14965   {
14966     try {
14967       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14975       };
14976     } catch (...) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14979       };
14980     }
14981   }
14982   jresult = (void *)result;
14983   return jresult;
14984 }
14985
14986
14987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14988   void * jresult ;
14989   Dali::AngleAxis *arg1 = 0 ;
14990   Dali::Property::Value *result = 0 ;
14991
14992   arg1 = (Dali::AngleAxis *)jarg1;
14993   if (!arg1) {
14994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14995     return 0;
14996   }
14997   {
14998     try {
14999       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (...) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15011       };
15012     }
15013   }
15014   jresult = (void *)result;
15015   return jresult;
15016 }
15017
15018
15019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15020   void * jresult ;
15021   Dali::Quaternion *arg1 = 0 ;
15022   Dali::Property::Value *result = 0 ;
15023
15024   arg1 = (Dali::Quaternion *)jarg1;
15025   if (!arg1) {
15026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15027     return 0;
15028   }
15029   {
15030     try {
15031       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (...) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15043       };
15044     }
15045   }
15046   jresult = (void *)result;
15047   return jresult;
15048 }
15049
15050
15051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15052   void * jresult ;
15053   std::string *arg1 = 0 ;
15054   Dali::Property::Value *result = 0 ;
15055
15056   if (!jarg1) {
15057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15058     return 0;
15059   }
15060   std::string arg1_str(jarg1);
15061   arg1 = &arg1_str;
15062   {
15063     try {
15064       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (...) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15076       };
15077     }
15078   }
15079   jresult = (void *)result;
15080
15081   //argout typemap for const std::string&
15082
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15088   void * jresult ;
15089   Dali::Property::Array *arg1 = 0 ;
15090   Dali::Property::Value *result = 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   if (!arg1) {
15094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15095     return 0;
15096   }
15097   {
15098     try {
15099       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15100     } catch (std::out_of_range& e) {
15101       {
15102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15103       };
15104     } catch (std::exception& e) {
15105       {
15106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15111       };
15112     }
15113   }
15114   jresult = (void *)result;
15115   return jresult;
15116 }
15117
15118
15119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15120   void * jresult ;
15121   Dali::Property::Map *arg1 = 0 ;
15122   Dali::Property::Value *result = 0 ;
15123
15124   arg1 = (Dali::Property::Map *)jarg1;
15125   if (!arg1) {
15126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15127     return 0;
15128   }
15129   {
15130     try {
15131       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15132     } catch (std::out_of_range& e) {
15133       {
15134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15135       };
15136     } catch (std::exception& e) {
15137       {
15138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15143       };
15144     }
15145   }
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15152   void * jresult ;
15153   Dali::Property::Type arg1 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   arg1 = (Dali::Property::Type)jarg1;
15157   {
15158     try {
15159       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15160     } catch (std::out_of_range& e) {
15161       {
15162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15163       };
15164     } catch (std::exception& e) {
15165       {
15166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15167       };
15168     } catch (...) {
15169       {
15170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15171       };
15172     }
15173   }
15174   jresult = (void *)result;
15175   return jresult;
15176 }
15177
15178
15179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15180   void * jresult ;
15181   Dali::Property::Value *arg1 = 0 ;
15182   Dali::Property::Value *result = 0 ;
15183
15184   arg1 = (Dali::Property::Value *)jarg1;
15185   if (!arg1) {
15186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15187     return 0;
15188   }
15189   {
15190     try {
15191       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (...) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15203       };
15204     }
15205   }
15206   jresult = (void *)result;
15207   return jresult;
15208 }
15209
15210
15211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15212   void * jresult ;
15213   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15214   Dali::Property::Value *arg2 = 0 ;
15215   Dali::Property::Value *result = 0 ;
15216
15217   arg1 = (Dali::Property::Value *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return 0;
15222   }
15223   {
15224     try {
15225       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15233       };
15234     } catch (...) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15237       };
15238     }
15239   }
15240   jresult = (void *)result;
15241   return jresult;
15242 }
15243
15244
15245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15246   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15247
15248   arg1 = (Dali::Property::Value *)jarg1;
15249   {
15250     try {
15251       delete arg1;
15252     } catch (std::out_of_range& e) {
15253       {
15254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15255       };
15256     } catch (std::exception& e) {
15257       {
15258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15259       };
15260     } catch (...) {
15261       {
15262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15263       };
15264     }
15265   }
15266 }
15267
15268
15269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15270   int jresult ;
15271   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15272   Dali::Property::Type result;
15273
15274   arg1 = (Dali::Property::Value *)jarg1;
15275   {
15276     try {
15277       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15278     } catch (std::out_of_range& e) {
15279       {
15280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15281       };
15282     } catch (std::exception& e) {
15283       {
15284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15285       };
15286     } catch (...) {
15287       {
15288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15289       };
15290     }
15291   }
15292   jresult = (int)result;
15293   return jresult;
15294 }
15295
15296
15297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15298   unsigned int jresult ;
15299   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15300   bool *arg2 = 0 ;
15301   bool result;
15302
15303   arg1 = (Dali::Property::Value *)jarg1;
15304   arg2 = (bool *)jarg2;
15305   {
15306     try {
15307       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15308     } catch (std::out_of_range& e) {
15309       {
15310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15311       };
15312     } catch (std::exception& e) {
15313       {
15314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15315       };
15316     } catch (...) {
15317       {
15318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15319       };
15320     }
15321   }
15322   jresult = result;
15323   return jresult;
15324 }
15325
15326
15327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15328   unsigned int jresult ;
15329   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15330   float *arg2 = 0 ;
15331   bool result;
15332
15333   arg1 = (Dali::Property::Value *)jarg1;
15334   arg2 = (float *)jarg2;
15335   {
15336     try {
15337       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15338     } catch (std::out_of_range& e) {
15339       {
15340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (std::exception& e) {
15343       {
15344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352   jresult = result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15358   unsigned int jresult ;
15359   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15360   int *arg2 = 0 ;
15361   bool result;
15362
15363   arg1 = (Dali::Property::Value *)jarg1;
15364   arg2 = (int *)jarg2;
15365   {
15366     try {
15367       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15368     } catch (std::out_of_range& e) {
15369       {
15370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15371       };
15372     } catch (std::exception& e) {
15373       {
15374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (...) {
15377       {
15378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15379       };
15380     }
15381   }
15382   jresult = result;
15383   return jresult;
15384 }
15385
15386
15387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15388   unsigned int jresult ;
15389   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15390   Dali::Rect< int > *arg2 = 0 ;
15391   bool result;
15392
15393   arg1 = (Dali::Property::Value *)jarg1;
15394   arg2 = (Dali::Rect< int > *)jarg2;
15395   if (!arg2) {
15396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15397     return 0;
15398   }
15399   {
15400     try {
15401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15402     } catch (std::out_of_range& e) {
15403       {
15404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15405       };
15406     } catch (std::exception& e) {
15407       {
15408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15409       };
15410     } catch (...) {
15411       {
15412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15413       };
15414     }
15415   }
15416   jresult = result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15422   unsigned int jresult ;
15423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15424   Dali::Vector2 *arg2 = 0 ;
15425   bool result;
15426
15427   arg1 = (Dali::Property::Value *)jarg1;
15428   arg2 = (Dali::Vector2 *)jarg2;
15429   if (!arg2) {
15430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15431     return 0;
15432   }
15433   {
15434     try {
15435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15436     } catch (std::out_of_range& e) {
15437       {
15438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15439       };
15440     } catch (std::exception& e) {
15441       {
15442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (...) {
15445       {
15446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15447       };
15448     }
15449   }
15450   jresult = result;
15451   return jresult;
15452 }
15453
15454
15455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15456   unsigned int jresult ;
15457   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15458   Dali::Vector3 *arg2 = 0 ;
15459   bool result;
15460
15461   arg1 = (Dali::Property::Value *)jarg1;
15462   arg2 = (Dali::Vector3 *)jarg2;
15463   if (!arg2) {
15464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15465     return 0;
15466   }
15467   {
15468     try {
15469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15470     } catch (std::out_of_range& e) {
15471       {
15472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15473       };
15474     } catch (std::exception& e) {
15475       {
15476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (...) {
15479       {
15480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15481       };
15482     }
15483   }
15484   jresult = result;
15485   return jresult;
15486 }
15487
15488
15489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15490   unsigned int jresult ;
15491   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15492   Dali::Vector4 *arg2 = 0 ;
15493   bool result;
15494
15495   arg1 = (Dali::Property::Value *)jarg1;
15496   arg2 = (Dali::Vector4 *)jarg2;
15497   if (!arg2) {
15498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15499     return 0;
15500   }
15501   {
15502     try {
15503       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15504     } catch (std::out_of_range& e) {
15505       {
15506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15507       };
15508     } catch (std::exception& e) {
15509       {
15510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15511       };
15512     } catch (...) {
15513       {
15514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15515       };
15516     }
15517   }
15518   jresult = result;
15519   return jresult;
15520 }
15521
15522
15523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15524   unsigned int jresult ;
15525   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15526   Dali::Matrix3 *arg2 = 0 ;
15527   bool result;
15528
15529   arg1 = (Dali::Property::Value *)jarg1;
15530   arg2 = (Dali::Matrix3 *)jarg2;
15531   if (!arg2) {
15532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15533     return 0;
15534   }
15535   {
15536     try {
15537       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15538     } catch (std::out_of_range& e) {
15539       {
15540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15541       };
15542     } catch (std::exception& e) {
15543       {
15544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15545       };
15546     } catch (...) {
15547       {
15548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15549       };
15550     }
15551   }
15552   jresult = result;
15553   return jresult;
15554 }
15555
15556
15557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15558   unsigned int jresult ;
15559   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15560   Dali::Matrix *arg2 = 0 ;
15561   bool result;
15562
15563   arg1 = (Dali::Property::Value *)jarg1;
15564   arg2 = (Dali::Matrix *)jarg2;
15565   if (!arg2) {
15566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15567     return 0;
15568   }
15569   {
15570     try {
15571       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15572     } catch (std::out_of_range& e) {
15573       {
15574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (std::exception& e) {
15577       {
15578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586   jresult = result;
15587   return jresult;
15588 }
15589
15590
15591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15592   unsigned int jresult ;
15593   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15594   Dali::AngleAxis *arg2 = 0 ;
15595   bool result;
15596
15597   arg1 = (Dali::Property::Value *)jarg1;
15598   arg2 = (Dali::AngleAxis *)jarg2;
15599   if (!arg2) {
15600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15601     return 0;
15602   }
15603   {
15604     try {
15605       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15606     } catch (std::out_of_range& e) {
15607       {
15608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15609       };
15610     } catch (std::exception& e) {
15611       {
15612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15613       };
15614     } catch (...) {
15615       {
15616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15617       };
15618     }
15619   }
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15628   Dali::Quaternion *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Value *)jarg1;
15632   arg2 = (Dali::Quaternion *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (...) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15651       };
15652     }
15653   }
15654   jresult = result;
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15660   unsigned int jresult ;
15661   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15662   std::string *arg2 = 0 ;
15663   bool result;
15664
15665   arg1 = (Dali::Property::Value *)jarg1;
15666
15667   //typemap in
15668   std::string temp;
15669   arg2 = &temp;
15670
15671   {
15672     try {
15673       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15674     } catch (std::out_of_range& e) {
15675       {
15676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (std::exception& e) {
15679       {
15680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (...) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15685       };
15686     }
15687   }
15688   jresult = result;
15689
15690   //Typemap argout in c++ file.
15691   //This will convert c++ string to c# string
15692   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15693
15694   return jresult;
15695 }
15696
15697
15698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15699   unsigned int jresult ;
15700   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15701   Dali::Property::Array *arg2 = 0 ;
15702   bool result;
15703
15704   arg1 = (Dali::Property::Value *)jarg1;
15705   arg2 = (Dali::Property::Array *)jarg2;
15706   if (!arg2) {
15707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15708     return 0;
15709   }
15710   {
15711     try {
15712       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15713     } catch (std::out_of_range& e) {
15714       {
15715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (std::exception& e) {
15718       {
15719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (...) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15724       };
15725     }
15726   }
15727   jresult = result;
15728   return jresult;
15729 }
15730
15731
15732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15733   unsigned int jresult ;
15734   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15735   Dali::Property::Map *arg2 = 0 ;
15736   bool result;
15737
15738   arg1 = (Dali::Property::Value *)jarg1;
15739   arg2 = (Dali::Property::Map *)jarg2;
15740   if (!arg2) {
15741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15742     return 0;
15743   }
15744   {
15745     try {
15746       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15747     } catch (std::out_of_range& e) {
15748       {
15749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15750       };
15751     } catch (std::exception& e) {
15752       {
15753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (...) {
15756       {
15757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15758       };
15759     }
15760   }
15761   jresult = result;
15762   return jresult;
15763 }
15764
15765
15766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15767   void * jresult ;
15768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15769   Dali::Property::Array *result = 0 ;
15770
15771   arg1 = (Dali::Property::Value *)jarg1;
15772   {
15773     try {
15774       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15775     } catch (std::out_of_range& e) {
15776       {
15777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15778       };
15779     } catch (std::exception& e) {
15780       {
15781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15782       };
15783     } catch (...) {
15784       {
15785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15786       };
15787     }
15788   }
15789   jresult = (void *)result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15795   void * jresult ;
15796   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15797   Dali::Property::Map *result = 0 ;
15798
15799   arg1 = (Dali::Property::Value *)jarg1;
15800   {
15801     try {
15802       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15803     } catch (std::out_of_range& e) {
15804       {
15805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15806       };
15807     } catch (std::exception& e) {
15808       {
15809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (...) {
15812       {
15813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15814       };
15815     }
15816   }
15817   jresult = (void *)result;
15818   return jresult;
15819 }
15820
15821
15822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15823   char * jresult ;
15824   Dali::Property::Type arg1 ;
15825   char *result = 0 ;
15826
15827   arg1 = (Dali::Property::Type)jarg1;
15828   {
15829     try {
15830       result = (char *)Dali::PropertyTypes::GetName(arg1);
15831     } catch (std::out_of_range& e) {
15832       {
15833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15834       };
15835     } catch (std::exception& e) {
15836       {
15837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15838       };
15839     } catch (...) {
15840       {
15841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15842       };
15843     }
15844   }
15845   jresult = SWIG_csharp_string_callback((const char *)result);
15846   return jresult;
15847 }
15848
15849
15850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15851   unsigned int jresult ;
15852   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15853   std::string *arg2 = 0 ;
15854   Dali::Property::Map *arg3 = 0 ;
15855   bool result;
15856
15857   arg1 = (Dali::BaseObject *)jarg1;
15858   if (!jarg2) {
15859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15860     return 0;
15861   }
15862   std::string arg2_str(jarg2);
15863   arg2 = &arg2_str;
15864   arg3 = (Dali::Property::Map *)jarg3;
15865   if (!arg3) {
15866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15867     return 0;
15868   }
15869   {
15870     try {
15871       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15872     } catch (std::out_of_range& e) {
15873       {
15874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15875       };
15876     } catch (std::exception& e) {
15877       {
15878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15879       };
15880     } catch (...) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15883       };
15884     }
15885   }
15886   jresult = result;
15887
15888   //argout typemap for const std::string&
15889
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15895   char * jresult ;
15896   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15897   std::string *result = 0 ;
15898
15899   arg1 = (Dali::BaseObject *)jarg1;
15900   {
15901     try {
15902       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (...) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15914       };
15915     }
15916   }
15917   jresult = SWIG_csharp_string_callback(result->c_str());
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15923   unsigned int jresult ;
15924   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15925   Dali::TypeInfo *arg2 = 0 ;
15926   bool result;
15927
15928   arg1 = (Dali::BaseObject *)jarg1;
15929   arg2 = (Dali::TypeInfo *)jarg2;
15930   if (!arg2) {
15931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15932     return 0;
15933   }
15934   {
15935     try {
15936       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15937     } catch (std::out_of_range& e) {
15938       {
15939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15940       };
15941     } catch (std::exception& e) {
15942       {
15943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15944       };
15945     } catch (...) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15948       };
15949     }
15950   }
15951   jresult = result;
15952   return jresult;
15953 }
15954
15955
15956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15957   unsigned int jresult ;
15958   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15959   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15960   std::string *arg3 = 0 ;
15961   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15962   bool result;
15963
15964   arg1 = (Dali::BaseObject *)jarg1;
15965   arg2 = (ConnectionTrackerInterface *)jarg2;
15966   if (!jarg3) {
15967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15968     return 0;
15969   }
15970   std::string arg3_str(jarg3);
15971   arg3 = &arg3_str;
15972   arg4 = (FunctorDelegate *)jarg4;
15973   {
15974     try {
15975       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15976     } catch (std::out_of_range& e) {
15977       {
15978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (std::exception& e) {
15981       {
15982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15983       };
15984     } catch (...) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15987       };
15988     }
15989   }
15990   jresult = result;
15991
15992   //argout typemap for const std::string&
15993
15994   return jresult;
15995 }
15996
15997
15998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15999   void * jresult ;
16000   Dali::BaseHandle *arg1 = 0 ;
16001   Dali::BaseObject *result = 0 ;
16002
16003   arg1 = (Dali::BaseHandle *)jarg1;
16004   if (!arg1) {
16005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16006     return 0;
16007   }
16008   {
16009     try {
16010       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16011     } catch (std::out_of_range& e) {
16012       {
16013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16014       };
16015     } catch (std::exception& e) {
16016       {
16017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16018       };
16019     } catch (...) {
16020       {
16021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16022       };
16023     }
16024   }
16025   jresult = (void *)result;
16026   return jresult;
16027 }
16028
16029
16030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16031   void * jresult ;
16032   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16033   Dali::BaseHandle *result = 0 ;
16034
16035   arg1 = (Dali::BaseObject *)jarg1;
16036   {
16037     try {
16038       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16039     } catch (std::out_of_range& e) {
16040       {
16041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16042       };
16043     } catch (std::exception& e) {
16044       {
16045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16046       };
16047     } catch (...) {
16048       {
16049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16050       };
16051     }
16052   }
16053   jresult = (void *)result;
16054   return jresult;
16055 }
16056
16057
16058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16059   void * jresult ;
16060   Dali::BaseHandle *result = 0 ;
16061
16062   {
16063     try {
16064       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16065     } catch (std::out_of_range& e) {
16066       {
16067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (std::exception& e) {
16070       {
16071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079   jresult = (void *)result;
16080   return jresult;
16081 }
16082
16083
16084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16085   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16086
16087   arg1 = (Dali::BaseHandle *)jarg1;
16088   {
16089     try {
16090       delete arg1;
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16098       };
16099     } catch (...) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16102       };
16103     }
16104   }
16105 }
16106
16107
16108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16109   void * jresult ;
16110   Dali::BaseHandle *arg1 = 0 ;
16111   Dali::BaseHandle *result = 0 ;
16112
16113   arg1 = (Dali::BaseHandle *)jarg1;
16114   if (!arg1) {
16115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16116     return 0;
16117   }
16118   {
16119     try {
16120       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16121     } catch (std::out_of_range& e) {
16122       {
16123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16124       };
16125     } catch (std::exception& e) {
16126       {
16127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16128       };
16129     } catch (...) {
16130       {
16131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16132       };
16133     }
16134   }
16135   jresult = (void *)result;
16136   return jresult;
16137 }
16138
16139
16140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16141   void * jresult ;
16142   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16143   Dali::BaseHandle *arg2 = 0 ;
16144   Dali::BaseHandle *result = 0 ;
16145
16146   arg1 = (Dali::BaseHandle *)jarg1;
16147   arg2 = (Dali::BaseHandle *)jarg2;
16148   if (!arg2) {
16149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16150     return 0;
16151   }
16152   {
16153     try {
16154       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16155     } catch (std::out_of_range& e) {
16156       {
16157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16158       };
16159     } catch (std::exception& e) {
16160       {
16161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16162       };
16163     } catch (...) {
16164       {
16165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16166       };
16167     }
16168   }
16169   jresult = (void *)result;
16170   return jresult;
16171 }
16172
16173
16174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16175   unsigned int jresult ;
16176   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16177   std::string *arg2 = 0 ;
16178   Dali::Property::Map *arg3 = 0 ;
16179   bool result;
16180
16181   arg1 = (Dali::BaseHandle *)jarg1;
16182   if (!jarg2) {
16183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16184     return 0;
16185   }
16186   std::string arg2_str(jarg2);
16187   arg2 = &arg2_str;
16188   arg3 = (Dali::Property::Map *)jarg3;
16189   if (!arg3) {
16190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16191     return 0;
16192   }
16193   {
16194     try {
16195       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16196     } catch (std::out_of_range& e) {
16197       {
16198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16199       };
16200     } catch (std::exception& e) {
16201       {
16202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16203       };
16204     } catch (...) {
16205       {
16206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16207       };
16208     }
16209   }
16210   jresult = result;
16211
16212   //argout typemap for const std::string&
16213
16214   return jresult;
16215 }
16216
16217
16218 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16219   char * jresult ;
16220   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16221   std::string *result = 0 ;
16222
16223   arg1 = (Dali::BaseHandle *)jarg1;
16224   {
16225     try {
16226       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16227     } catch (std::out_of_range& e) {
16228       {
16229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16230       };
16231     } catch (std::exception& e) {
16232       {
16233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16234       };
16235     } catch (...) {
16236       {
16237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16238       };
16239     }
16240   }
16241   jresult = SWIG_csharp_string_callback(result->c_str());
16242   return jresult;
16243 }
16244
16245
16246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16247   unsigned int jresult ;
16248   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16249   Dali::TypeInfo *arg2 = 0 ;
16250   bool result;
16251
16252   arg1 = (Dali::BaseHandle *)jarg1;
16253   arg2 = (Dali::TypeInfo *)jarg2;
16254   if (!arg2) {
16255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16256     return 0;
16257   }
16258   {
16259     try {
16260       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16261     } catch (std::out_of_range& e) {
16262       {
16263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16264       };
16265     } catch (std::exception& e) {
16266       {
16267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16268       };
16269     } catch (...) {
16270       {
16271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16272       };
16273     }
16274   }
16275   jresult = result;
16276   return jresult;
16277 }
16278
16279
16280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16281   void * jresult ;
16282   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16283   Dali::BaseObject *result = 0 ;
16284
16285   arg1 = (Dali::BaseHandle *)jarg1;
16286   {
16287     try {
16288       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16289     } catch (std::out_of_range& e) {
16290       {
16291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16292       };
16293     } catch (std::exception& e) {
16294       {
16295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16296       };
16297     } catch (...) {
16298       {
16299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16300       };
16301     }
16302   }
16303   jresult = (void *)result;
16304   return jresult;
16305 }
16306
16307
16308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16309   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16310
16311   arg1 = (Dali::BaseHandle *)jarg1;
16312   {
16313     try {
16314       (arg1)->Reset();
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16322       };
16323     } catch (...) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16326       };
16327     }
16328   }
16329 }
16330
16331
16332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16333   unsigned int jresult ;
16334   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16335   Dali::BaseHandle *arg2 = 0 ;
16336   bool result;
16337
16338   arg1 = (Dali::BaseHandle *)jarg1;
16339   arg2 = (Dali::BaseHandle *)jarg2;
16340   if (!arg2) {
16341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16342     return 0;
16343   }
16344   {
16345     try {
16346       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16347     } catch (std::out_of_range& e) {
16348       {
16349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16350       };
16351     } catch (std::exception& e) {
16352       {
16353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (...) {
16356       {
16357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16358       };
16359     }
16360   }
16361   jresult = result;
16362   return jresult;
16363 }
16364
16365
16366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16367   unsigned int jresult ;
16368   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16369   Dali::BaseHandle *arg2 = 0 ;
16370   bool result;
16371
16372   arg1 = (Dali::BaseHandle *)jarg1;
16373   arg2 = (Dali::BaseHandle *)jarg2;
16374   if (!arg2) {
16375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16376     return 0;
16377   }
16378   {
16379     try {
16380       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16381     } catch (std::out_of_range& e) {
16382       {
16383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16384       };
16385     } catch (std::exception& e) {
16386       {
16387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16388       };
16389     } catch (...) {
16390       {
16391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16392       };
16393     }
16394   }
16395   jresult = result;
16396   return jresult;
16397 }
16398
16399
16400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16401   void * jresult ;
16402   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16403   Dali::RefObject *result = 0 ;
16404
16405   arg1 = (Dali::BaseHandle *)jarg1;
16406   {
16407     try {
16408       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16409     } catch (std::out_of_range& e) {
16410       {
16411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (std::exception& e) {
16414       {
16415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16416       };
16417     } catch (...) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16420       };
16421     }
16422   }
16423   jresult = (void *)result;
16424   return jresult;
16425 }
16426
16427
16428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16429   unsigned int jresult ;
16430   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16431   bool result;
16432
16433   arg1 = (Dali::BaseHandle *)jarg1;
16434   {
16435     try {
16436       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16437     } catch (std::out_of_range& e) {
16438       {
16439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16440       };
16441     } catch (std::exception& e) {
16442       {
16443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (...) {
16446       {
16447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16448       };
16449     }
16450   }
16451   jresult = result;
16452   return jresult;
16453 }
16454
16455
16456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16457   unsigned int jresult ;
16458   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16459   Dali::BaseHandle *arg2 = 0 ;
16460   bool result;
16461
16462   arg1 = (Dali::BaseHandle *)jarg1;
16463   arg2 = (Dali::BaseHandle *)jarg2;
16464   if (!arg2) {
16465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16466     return 0;
16467   }
16468   {
16469     try {
16470       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16478       };
16479     } catch (...) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16482       };
16483     }
16484   }
16485   jresult = result;
16486   return jresult;
16487 }
16488
16489
16490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16491   unsigned int jresult ;
16492   Dali::BaseHandle *arg1 = 0 ;
16493   Dali::BaseHandle *arg2 = 0 ;
16494   bool result;
16495
16496   arg1 = (Dali::BaseHandle *)jarg1;
16497   if (!arg1) {
16498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16499     return 0;
16500   }
16501   arg2 = (Dali::BaseHandle *)jarg2;
16502   if (!arg2) {
16503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16504     return 0;
16505   }
16506   {
16507     try {
16508       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16509     } catch (std::out_of_range& e) {
16510       {
16511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16512       };
16513     } catch (std::exception& e) {
16514       {
16515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16520       };
16521     }
16522   }
16523   jresult = result;
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16529   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16530
16531   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16532   {
16533     try {
16534       delete arg1;
16535     } catch (std::out_of_range& e) {
16536       {
16537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16538       };
16539     } catch (std::exception& e) {
16540       {
16541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16542       };
16543     } catch (...) {
16544       {
16545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16546       };
16547     }
16548   }
16549 }
16550
16551
16552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16553   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16554   SlotObserver *arg2 = (SlotObserver *) 0 ;
16555   CallbackBase *arg3 = (CallbackBase *) 0 ;
16556
16557   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16558   arg2 = (SlotObserver *)jarg2;
16559   arg3 = (CallbackBase *)jarg3;
16560   {
16561     try {
16562       (arg1)->SignalConnected(arg2,arg3);
16563     } catch (std::out_of_range& e) {
16564       {
16565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16566       };
16567     } catch (std::exception& e) {
16568       {
16569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16570       };
16571     } catch (...) {
16572       {
16573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16574       };
16575     }
16576   }
16577 }
16578
16579
16580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16581   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16582
16583   arg1 = (Dali::SignalObserver *)jarg1;
16584   {
16585     try {
16586       delete arg1;
16587     } catch (std::out_of_range& e) {
16588       {
16589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16590       };
16591     } catch (std::exception& e) {
16592       {
16593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16594       };
16595     } catch (...) {
16596       {
16597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16598       };
16599     }
16600   }
16601 }
16602
16603
16604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16605   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16606   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16607   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16608
16609   arg1 = (Dali::SignalObserver *)jarg1;
16610   arg2 = (Dali::SlotObserver *)jarg2;
16611   arg3 = (Dali::CallbackBase *)jarg3;
16612   {
16613     try {
16614       (arg1)->SignalDisconnected(arg2,arg3);
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16622       };
16623     } catch (...) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16626       };
16627     }
16628   }
16629 }
16630
16631
16632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16633   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16634
16635   arg1 = (Dali::SlotObserver *)jarg1;
16636   {
16637     try {
16638       delete arg1;
16639     } catch (std::out_of_range& e) {
16640       {
16641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (std::exception& e) {
16644       {
16645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16646       };
16647     } catch (...) {
16648       {
16649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16650       };
16651     }
16652   }
16653 }
16654
16655
16656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16657   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16658   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16659
16660   arg1 = (Dali::SlotObserver *)jarg1;
16661   arg2 = (Dali::CallbackBase *)jarg2;
16662   {
16663     try {
16664       (arg1)->SlotDisconnected(arg2);
16665     } catch (std::out_of_range& e) {
16666       {
16667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16668       };
16669     } catch (std::exception& e) {
16670       {
16671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16672       };
16673     } catch (...) {
16674       {
16675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16676       };
16677     }
16678   }
16679 }
16680
16681
16682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16683   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16684
16685   arg1 = (Dali::ConnectionTracker *)jarg1;
16686   {
16687     try {
16688       delete arg1;
16689     } catch (std::out_of_range& e) {
16690       {
16691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16692       };
16693     } catch (std::exception& e) {
16694       {
16695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16700       };
16701     }
16702   }
16703 }
16704
16705
16706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16707   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16708
16709   arg1 = (Dali::ConnectionTracker *)jarg1;
16710   {
16711     try {
16712       (arg1)->DisconnectAll();
16713     } catch (std::out_of_range& e) {
16714       {
16715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16716       };
16717     } catch (std::exception& e) {
16718       {
16719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16720       };
16721     } catch (...) {
16722       {
16723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16724       };
16725     }
16726   }
16727 }
16728
16729
16730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16731   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16732   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16733   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16734
16735   arg1 = (Dali::ConnectionTracker *)jarg1;
16736   arg2 = (Dali::SlotObserver *)jarg2;
16737   arg3 = (Dali::CallbackBase *)jarg3;
16738   {
16739     try {
16740       (arg1)->SignalConnected(arg2,arg3);
16741     } catch (std::out_of_range& e) {
16742       {
16743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16744       };
16745     } catch (std::exception& e) {
16746       {
16747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16748       };
16749     } catch (...) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16752       };
16753     }
16754   }
16755 }
16756
16757
16758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16759   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16760   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16761   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16762
16763   arg1 = (Dali::ConnectionTracker *)jarg1;
16764   arg2 = (Dali::SlotObserver *)jarg2;
16765   arg3 = (Dali::CallbackBase *)jarg3;
16766   {
16767     try {
16768       (arg1)->SignalDisconnected(arg2,arg3);
16769     } catch (std::out_of_range& e) {
16770       {
16771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (std::exception& e) {
16774       {
16775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16776       };
16777     } catch (...) {
16778       {
16779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16780       };
16781     }
16782   }
16783 }
16784
16785
16786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16787   unsigned long jresult ;
16788   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16789   std::size_t result;
16790
16791   arg1 = (Dali::ConnectionTracker *)jarg1;
16792   {
16793     try {
16794       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16795     } catch (std::out_of_range& e) {
16796       {
16797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16798       };
16799     } catch (std::exception& e) {
16800       {
16801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16802       };
16803     } catch (...) {
16804       {
16805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16806       };
16807     }
16808   }
16809   jresult = (unsigned long)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16815   void * jresult ;
16816   Dali::ObjectRegistry *result = 0 ;
16817
16818   {
16819     try {
16820       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (...) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16832       };
16833     }
16834   }
16835   jresult = (void *)result;
16836   return jresult;
16837 }
16838
16839
16840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16841   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16842
16843   arg1 = (Dali::ObjectRegistry *)jarg1;
16844   {
16845     try {
16846       delete arg1;
16847     } catch (std::out_of_range& e) {
16848       {
16849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16850       };
16851     } catch (std::exception& e) {
16852       {
16853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16854       };
16855     } catch (...) {
16856       {
16857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16858       };
16859     }
16860   }
16861 }
16862
16863
16864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16865   void * jresult ;
16866   Dali::ObjectRegistry *arg1 = 0 ;
16867   Dali::ObjectRegistry *result = 0 ;
16868
16869   arg1 = (Dali::ObjectRegistry *)jarg1;
16870   if (!arg1) {
16871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16872     return 0;
16873   }
16874   {
16875     try {
16876       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16877     } catch (std::out_of_range& e) {
16878       {
16879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16880       };
16881     } catch (std::exception& e) {
16882       {
16883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16884       };
16885     } catch (...) {
16886       {
16887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16888       };
16889     }
16890   }
16891   jresult = (void *)result;
16892   return jresult;
16893 }
16894
16895
16896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16897   void * jresult ;
16898   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16899   Dali::ObjectRegistry *arg2 = 0 ;
16900   Dali::ObjectRegistry *result = 0 ;
16901
16902   arg1 = (Dali::ObjectRegistry *)jarg1;
16903   arg2 = (Dali::ObjectRegistry *)jarg2;
16904   if (!arg2) {
16905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16906     return 0;
16907   }
16908   {
16909     try {
16910       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16911     } catch (std::out_of_range& e) {
16912       {
16913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16914       };
16915     } catch (std::exception& e) {
16916       {
16917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16918       };
16919     } catch (...) {
16920       {
16921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16922       };
16923     }
16924   }
16925   jresult = (void *)result;
16926   return jresult;
16927 }
16928
16929
16930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16931   void * jresult ;
16932   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16933   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16934
16935   arg1 = (Dali::ObjectRegistry *)jarg1;
16936   {
16937     try {
16938       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16939     } catch (std::out_of_range& e) {
16940       {
16941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (std::exception& e) {
16944       {
16945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953   jresult = (void *)result;
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16959   void * jresult ;
16960   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16961   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16962
16963   arg1 = (Dali::ObjectRegistry *)jarg1;
16964   {
16965     try {
16966       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16967     } catch (std::out_of_range& e) {
16968       {
16969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16970       };
16971     } catch (std::exception& e) {
16972       {
16973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (...) {
16976       {
16977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16978       };
16979     }
16980   }
16981   jresult = (void *)result;
16982   return jresult;
16983 }
16984
16985
16986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16987   void * jresult ;
16988   Dali::PropertyCondition *result = 0 ;
16989
16990   {
16991     try {
16992       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16993     } catch (std::out_of_range& e) {
16994       {
16995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (std::exception& e) {
16998       {
16999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17000       };
17001     } catch (...) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17004       };
17005     }
17006   }
17007   jresult = (void *)result;
17008   return jresult;
17009 }
17010
17011
17012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17013   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17014
17015   arg1 = (Dali::PropertyCondition *)jarg1;
17016   {
17017     try {
17018       delete arg1;
17019     } catch (std::out_of_range& e) {
17020       {
17021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17022       };
17023     } catch (std::exception& e) {
17024       {
17025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17026       };
17027     } catch (...) {
17028       {
17029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17030       };
17031     }
17032   }
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17037   void * jresult ;
17038   Dali::PropertyCondition *arg1 = 0 ;
17039   Dali::PropertyCondition *result = 0 ;
17040
17041   arg1 = (Dali::PropertyCondition *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (...) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17060       };
17061     }
17062   }
17063   jresult = (void *)result;
17064   return jresult;
17065 }
17066
17067
17068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17069   void * jresult ;
17070   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17071   Dali::PropertyCondition *arg2 = 0 ;
17072   Dali::PropertyCondition *result = 0 ;
17073
17074   arg1 = (Dali::PropertyCondition *)jarg1;
17075   arg2 = (Dali::PropertyCondition *)jarg2;
17076   if (!arg2) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17078     return 0;
17079   }
17080   {
17081     try {
17082       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17083     } catch (std::out_of_range& e) {
17084       {
17085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (std::exception& e) {
17088       {
17089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (...) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17094       };
17095     }
17096   }
17097   jresult = (void *)result;
17098   return jresult;
17099 }
17100
17101
17102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17103   unsigned long jresult ;
17104   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17105   std::size_t result;
17106
17107   arg1 = (Dali::PropertyCondition *)jarg1;
17108   {
17109     try {
17110       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17111     } catch (std::out_of_range& e) {
17112       {
17113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17114       };
17115     } catch (std::exception& e) {
17116       {
17117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17118       };
17119     } catch (...) {
17120       {
17121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17122       };
17123     }
17124   }
17125   jresult = (unsigned long)result;
17126   return jresult;
17127 }
17128
17129
17130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17131   float jresult ;
17132   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17133   std::size_t arg2 ;
17134   float result;
17135
17136   arg1 = (Dali::PropertyCondition *)jarg1;
17137   arg2 = (std::size_t)jarg2;
17138   {
17139     try {
17140       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17141     } catch (std::out_of_range& e) {
17142       {
17143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17144       };
17145     } catch (std::exception& e) {
17146       {
17147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (...) {
17150       {
17151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17152       };
17153     }
17154   }
17155   jresult = result;
17156   return jresult;
17157 }
17158
17159
17160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17161   void * jresult ;
17162   float arg1 ;
17163   Dali::PropertyCondition result;
17164
17165   arg1 = (float)jarg1;
17166   {
17167     try {
17168       result = Dali::LessThanCondition(arg1);
17169     } catch (std::out_of_range& e) {
17170       {
17171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17172       };
17173     } catch (std::exception& e) {
17174       {
17175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17176       };
17177     } catch (...) {
17178       {
17179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17180       };
17181     }
17182   }
17183   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17189   void * jresult ;
17190   float arg1 ;
17191   Dali::PropertyCondition result;
17192
17193   arg1 = (float)jarg1;
17194   {
17195     try {
17196       result = Dali::GreaterThanCondition(arg1);
17197     } catch (std::out_of_range& e) {
17198       {
17199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (std::exception& e) {
17202       {
17203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (...) {
17206       {
17207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17208       };
17209     }
17210   }
17211   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17212   return jresult;
17213 }
17214
17215
17216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17217   void * jresult ;
17218   float arg1 ;
17219   float arg2 ;
17220   Dali::PropertyCondition result;
17221
17222   arg1 = (float)jarg1;
17223   arg2 = (float)jarg2;
17224   {
17225     try {
17226       result = Dali::InsideCondition(arg1,arg2);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (...) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17238       };
17239     }
17240   }
17241   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17242   return jresult;
17243 }
17244
17245
17246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17247   void * jresult ;
17248   float arg1 ;
17249   float arg2 ;
17250   Dali::PropertyCondition result;
17251
17252   arg1 = (float)jarg1;
17253   arg2 = (float)jarg2;
17254   {
17255     try {
17256       result = Dali::OutsideCondition(arg1,arg2);
17257     } catch (std::out_of_range& e) {
17258       {
17259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17260       };
17261     } catch (std::exception& e) {
17262       {
17263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17264       };
17265     } catch (...) {
17266       {
17267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17268       };
17269     }
17270   }
17271   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17272   return jresult;
17273 }
17274
17275
17276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17277   void * jresult ;
17278   float arg1 ;
17279   float arg2 ;
17280   Dali::PropertyCondition result;
17281
17282   arg1 = (float)jarg1;
17283   arg2 = (float)jarg2;
17284   {
17285     try {
17286       result = Dali::StepCondition(arg1,arg2);
17287     } catch (std::out_of_range& e) {
17288       {
17289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17290       };
17291     } catch (std::exception& e) {
17292       {
17293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17294       };
17295     } catch (...) {
17296       {
17297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17298       };
17299     }
17300   }
17301   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17302   return jresult;
17303 }
17304
17305
17306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17307   void * jresult ;
17308   float arg1 ;
17309   Dali::PropertyCondition result;
17310
17311   arg1 = (float)jarg1;
17312   {
17313     try {
17314       result = Dali::StepCondition(arg1);
17315     } catch (std::out_of_range& e) {
17316       {
17317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17318       };
17319     } catch (std::exception& e) {
17320       {
17321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17322       };
17323     } catch (...) {
17324       {
17325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17326       };
17327     }
17328   }
17329   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17330   return jresult;
17331 }
17332
17333
17334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17335   void * jresult ;
17336   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17337   Dali::PropertyCondition result;
17338
17339   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17340   if (!arg1) {
17341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17342     return 0;
17343   }
17344   {
17345     try {
17346       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17347     } catch (std::out_of_range& e) {
17348       {
17349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17350       };
17351     } catch (std::exception& e) {
17352       {
17353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17354       };
17355     } catch (...) {
17356       {
17357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17358       };
17359     }
17360   }
17361   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17362   return jresult;
17363 }
17364
17365
17366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17367   void * jresult ;
17368   Dali::PropertyNotification *result = 0 ;
17369
17370   {
17371     try {
17372       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17373     } catch (std::out_of_range& e) {
17374       {
17375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17376       };
17377     } catch (std::exception& e) {
17378       {
17379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17380       };
17381     } catch (...) {
17382       {
17383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17384       };
17385     }
17386   }
17387   jresult = (void *)result;
17388   return jresult;
17389 }
17390
17391
17392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17393   void * jresult ;
17394   Dali::BaseHandle arg1 ;
17395   Dali::BaseHandle *argp1 ;
17396   Dali::PropertyNotification result;
17397
17398   argp1 = (Dali::BaseHandle *)jarg1;
17399   if (!argp1) {
17400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17401     return 0;
17402   }
17403   arg1 = *argp1;
17404   {
17405     try {
17406       result = Dali::PropertyNotification::DownCast(arg1);
17407     } catch (std::out_of_range& e) {
17408       {
17409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17410       };
17411     } catch (std::exception& e) {
17412       {
17413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17414       };
17415     } catch (...) {
17416       {
17417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17418       };
17419     }
17420   }
17421   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17427   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17428
17429   arg1 = (Dali::PropertyNotification *)jarg1;
17430   {
17431     try {
17432       delete arg1;
17433     } catch (std::out_of_range& e) {
17434       {
17435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17436       };
17437     } catch (std::exception& e) {
17438       {
17439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17440       };
17441     } catch (...) {
17442       {
17443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17444       };
17445     }
17446   }
17447 }
17448
17449
17450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17451   void * jresult ;
17452   Dali::PropertyNotification *arg1 = 0 ;
17453   Dali::PropertyNotification *result = 0 ;
17454
17455   arg1 = (Dali::PropertyNotification *)jarg1;
17456   if (!arg1) {
17457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17458     return 0;
17459   }
17460   {
17461     try {
17462       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17463     } catch (std::out_of_range& e) {
17464       {
17465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17466       };
17467     } catch (std::exception& e) {
17468       {
17469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17470       };
17471     } catch (...) {
17472       {
17473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17474       };
17475     }
17476   }
17477   jresult = (void *)result;
17478   return jresult;
17479 }
17480
17481
17482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17483   void * jresult ;
17484   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17485   Dali::PropertyNotification *arg2 = 0 ;
17486   Dali::PropertyNotification *result = 0 ;
17487
17488   arg1 = (Dali::PropertyNotification *)jarg1;
17489   arg2 = (Dali::PropertyNotification *)jarg2;
17490   if (!arg2) {
17491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17492     return 0;
17493   }
17494   {
17495     try {
17496       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17497     } catch (std::out_of_range& e) {
17498       {
17499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17500       };
17501     } catch (std::exception& e) {
17502       {
17503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17504       };
17505     } catch (...) {
17506       {
17507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17508       };
17509     }
17510   }
17511   jresult = (void *)result;
17512   return jresult;
17513 }
17514
17515
17516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17517   void * jresult ;
17518   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17519   Dali::PropertyCondition result;
17520
17521   arg1 = (Dali::PropertyNotification *)jarg1;
17522   {
17523     try {
17524       result = (arg1)->GetCondition();
17525     } catch (std::out_of_range& e) {
17526       {
17527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17528       };
17529     } catch (std::exception& e) {
17530       {
17531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (...) {
17534       {
17535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17536       };
17537     }
17538   }
17539   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17540   return jresult;
17541 }
17542
17543
17544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17545   void * jresult ;
17546   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17547   Dali::Handle result;
17548
17549   arg1 = (Dali::PropertyNotification *)jarg1;
17550   {
17551     try {
17552       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17553     } catch (std::out_of_range& e) {
17554       {
17555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17556       };
17557     } catch (std::exception& e) {
17558       {
17559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17560       };
17561     } catch (...) {
17562       {
17563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17564       };
17565     }
17566   }
17567   jresult = new Dali::Handle((const Dali::Handle &)result);
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17573   int jresult ;
17574   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17575   Dali::Property::Index result;
17576
17577   arg1 = (Dali::PropertyNotification *)jarg1;
17578   {
17579     try {
17580       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17581     } catch (std::out_of_range& e) {
17582       {
17583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (std::exception& e) {
17586       {
17587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (...) {
17590       {
17591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17592       };
17593     }
17594   }
17595   jresult = result;
17596   return jresult;
17597 }
17598
17599
17600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17601   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17602   Dali::PropertyNotification::NotifyMode arg2 ;
17603
17604   arg1 = (Dali::PropertyNotification *)jarg1;
17605   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17606   {
17607     try {
17608       (arg1)->SetNotifyMode(arg2);
17609     } catch (std::out_of_range& e) {
17610       {
17611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17612       };
17613     } catch (std::exception& e) {
17614       {
17615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17616       };
17617     } catch (...) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17620       };
17621     }
17622   }
17623 }
17624
17625
17626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17627   int jresult ;
17628   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17629   Dali::PropertyNotification::NotifyMode result;
17630
17631   arg1 = (Dali::PropertyNotification *)jarg1;
17632   {
17633     try {
17634       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17635     } catch (std::out_of_range& e) {
17636       {
17637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17638       };
17639     } catch (std::exception& e) {
17640       {
17641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17642       };
17643     } catch (...) {
17644       {
17645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17646       };
17647     }
17648   }
17649   jresult = (int)result;
17650   return jresult;
17651 }
17652
17653
17654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17655   unsigned int jresult ;
17656   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17657   bool result;
17658
17659   arg1 = (Dali::PropertyNotification *)jarg1;
17660   {
17661     try {
17662       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17663     } catch (std::out_of_range& e) {
17664       {
17665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (std::exception& e) {
17668       {
17669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (...) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17674       };
17675     }
17676   }
17677   jresult = result;
17678   return jresult;
17679 }
17680
17681
17682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17683   void * jresult ;
17684   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17685   Dali::PropertyNotifySignalType *result = 0 ;
17686
17687   arg1 = (Dali::PropertyNotification *)jarg1;
17688   {
17689     try {
17690       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17691     } catch (std::out_of_range& e) {
17692       {
17693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17694       };
17695     } catch (std::exception& e) {
17696       {
17697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17698       };
17699     } catch (...) {
17700       {
17701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17702       };
17703     }
17704   }
17705   jresult = (void *)result;
17706   return jresult;
17707 }
17708
17709
17710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17711   void * jresult ;
17712   Dali::Handle *result = 0 ;
17713
17714   {
17715     try {
17716       result = (Dali::Handle *)new Dali::Handle();
17717     } catch (std::out_of_range& e) {
17718       {
17719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17720       };
17721     } catch (std::exception& e) {
17722       {
17723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17724       };
17725     } catch (...) {
17726       {
17727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17728       };
17729     }
17730   }
17731   jresult = (void *)result;
17732   return jresult;
17733 }
17734
17735
17736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17737   void * jresult ;
17738   Dali::Handle result;
17739
17740   {
17741     try {
17742       result = Dali::Handle::New();
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757   jresult = new Dali::Handle((const Dali::Handle &)result);
17758   return jresult;
17759 }
17760
17761
17762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17763   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17764
17765   arg1 = (Dali::Handle *)jarg1;
17766   {
17767     try {
17768       delete arg1;
17769     } catch (std::out_of_range& e) {
17770       {
17771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17772       };
17773     } catch (std::exception& e) {
17774       {
17775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17776       };
17777     } catch (...) {
17778       {
17779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17780       };
17781     }
17782   }
17783 }
17784
17785
17786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17787   void * jresult ;
17788   Dali::Handle *arg1 = 0 ;
17789   Dali::Handle *result = 0 ;
17790
17791   arg1 = (Dali::Handle *)jarg1;
17792   if (!arg1) {
17793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17794     return 0;
17795   }
17796   {
17797     try {
17798       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17799     } catch (std::out_of_range& e) {
17800       {
17801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17802       };
17803     } catch (std::exception& e) {
17804       {
17805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (...) {
17808       {
17809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17810       };
17811     }
17812   }
17813   jresult = (void *)result;
17814   return jresult;
17815 }
17816
17817
17818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17819   void * jresult ;
17820   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17821   Dali::Handle *arg2 = 0 ;
17822   Dali::Handle *result = 0 ;
17823
17824   arg1 = (Dali::Handle *)jarg1;
17825   arg2 = (Dali::Handle *)jarg2;
17826   if (!arg2) {
17827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17828     return 0;
17829   }
17830   {
17831     try {
17832       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17833     } catch (std::out_of_range& e) {
17834       {
17835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17836       };
17837     } catch (std::exception& e) {
17838       {
17839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17840       };
17841     } catch (...) {
17842       {
17843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17844       };
17845     }
17846   }
17847   jresult = (void *)result;
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17853   void * jresult ;
17854   Dali::BaseHandle arg1 ;
17855   Dali::BaseHandle *argp1 ;
17856   Dali::Handle result;
17857
17858   argp1 = (Dali::BaseHandle *)jarg1;
17859   if (!argp1) {
17860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17861     return 0;
17862   }
17863   arg1 = *argp1;
17864   {
17865     try {
17866       result = Dali::Handle::DownCast(arg1);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (...) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17878       };
17879     }
17880   }
17881   jresult = new Dali::Handle((const Dali::Handle &)result);
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17887   unsigned int jresult ;
17888   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17889   Dali::Handle::Capability arg2 ;
17890   bool result;
17891
17892   arg1 = (Dali::Handle *)jarg1;
17893   arg2 = (Dali::Handle::Capability)jarg2;
17894   {
17895     try {
17896       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17897     } catch (std::out_of_range& e) {
17898       {
17899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17900       };
17901     } catch (std::exception& e) {
17902       {
17903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (...) {
17906       {
17907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17908       };
17909     }
17910   }
17911   jresult = result;
17912   return jresult;
17913 }
17914
17915
17916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17917   unsigned int jresult ;
17918   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17919   unsigned int result;
17920
17921   arg1 = (Dali::Handle *)jarg1;
17922   {
17923     try {
17924       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17925     } catch (std::out_of_range& e) {
17926       {
17927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (std::exception& e) {
17930       {
17931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17932       };
17933     } catch (...) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17936       };
17937     }
17938   }
17939   jresult = result;
17940   return jresult;
17941 }
17942
17943
17944 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17945   char * jresult ;
17946   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17947   Dali::Property::Index arg2 ;
17948   std::string result;
17949
17950   arg1 = (Dali::Handle *)jarg1;
17951   arg2 = (Dali::Property::Index)jarg2;
17952   {
17953     try {
17954       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17955     } catch (std::out_of_range& e) {
17956       {
17957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17958       };
17959     } catch (std::exception& e) {
17960       {
17961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17962       };
17963     } catch (...) {
17964       {
17965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17966       };
17967     }
17968   }
17969   jresult = SWIG_csharp_string_callback((&result)->c_str());
17970   return jresult;
17971 }
17972
17973
17974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17975   int jresult ;
17976   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17977   std::string *arg2 = 0 ;
17978   Dali::Property::Index result;
17979
17980   arg1 = (Dali::Handle *)jarg1;
17981   if (!jarg2) {
17982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17983     return 0;
17984   }
17985   std::string arg2_str(jarg2);
17986   arg2 = &arg2_str;
17987   {
17988     try {
17989       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17990     } catch (std::out_of_range& e) {
17991       {
17992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17993       };
17994     } catch (std::exception& e) {
17995       {
17996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17997       };
17998     } catch (...) {
17999       {
18000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18001       };
18002     }
18003   }
18004   jresult = result;
18005
18006   //argout typemap for const std::string&
18007
18008   return jresult;
18009 }
18010
18011
18012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18013   unsigned int jresult ;
18014   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18015   Dali::Property::Index arg2 ;
18016   bool result;
18017
18018   arg1 = (Dali::Handle *)jarg1;
18019   arg2 = (Dali::Property::Index)jarg2;
18020   {
18021     try {
18022       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18023     } catch (std::out_of_range& e) {
18024       {
18025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18026       };
18027     } catch (std::exception& e) {
18028       {
18029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (...) {
18032       {
18033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18034       };
18035     }
18036   }
18037   jresult = result;
18038   return jresult;
18039 }
18040
18041
18042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18043   unsigned int jresult ;
18044   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18045   Dali::Property::Index arg2 ;
18046   bool result;
18047
18048   arg1 = (Dali::Handle *)jarg1;
18049   arg2 = (Dali::Property::Index)jarg2;
18050   {
18051     try {
18052       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18053     } catch (std::out_of_range& e) {
18054       {
18055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18056       };
18057     } catch (std::exception& e) {
18058       {
18059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (...) {
18062       {
18063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18064       };
18065     }
18066   }
18067   jresult = result;
18068   return jresult;
18069 }
18070
18071
18072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18073   unsigned int jresult ;
18074   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18075   Dali::Property::Index arg2 ;
18076   bool result;
18077
18078   arg1 = (Dali::Handle *)jarg1;
18079   arg2 = (Dali::Property::Index)jarg2;
18080   {
18081     try {
18082       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (...) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18094       };
18095     }
18096   }
18097   jresult = result;
18098   return jresult;
18099 }
18100
18101
18102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18103   int jresult ;
18104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18105   Dali::Property::Index arg2 ;
18106   Dali::Property::Type result;
18107
18108   arg1 = (Dali::Handle *)jarg1;
18109   arg2 = (Dali::Property::Index)jarg2;
18110   {
18111     try {
18112       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18113     } catch (std::out_of_range& e) {
18114       {
18115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18116       };
18117     } catch (std::exception& e) {
18118       {
18119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18120       };
18121     } catch (...) {
18122       {
18123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18124       };
18125     }
18126   }
18127   jresult = (int)result;
18128   return jresult;
18129 }
18130
18131
18132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18133   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18134   Dali::Property::Index arg2 ;
18135   Dali::Property::Value *arg3 = 0 ;
18136
18137   arg1 = (Dali::Handle *)jarg1;
18138   arg2 = (Dali::Property::Index)jarg2;
18139   arg3 = (Dali::Property::Value *)jarg3;
18140   if (!arg3) {
18141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18142     return ;
18143   }
18144   {
18145     try {
18146       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18147     } catch (std::out_of_range& e) {
18148       {
18149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18150       };
18151     } catch (std::exception& e) {
18152       {
18153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18154       };
18155     } catch (...) {
18156       {
18157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18158       };
18159     }
18160   }
18161 }
18162
18163
18164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18165   int jresult ;
18166   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18167   std::string *arg2 = 0 ;
18168   Dali::Property::Value *arg3 = 0 ;
18169   Dali::Property::Index result;
18170
18171   arg1 = (Dali::Handle *)jarg1;
18172   if (!jarg2) {
18173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18174     return 0;
18175   }
18176   std::string arg2_str(jarg2);
18177   arg2 = &arg2_str;
18178   arg3 = (Dali::Property::Value *)jarg3;
18179   if (!arg3) {
18180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18181     return 0;
18182   }
18183   {
18184     try {
18185       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18186     } catch (std::out_of_range& e) {
18187       {
18188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18189       };
18190     } catch (std::exception& e) {
18191       {
18192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (...) {
18195       {
18196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18197       };
18198     }
18199   }
18200   jresult = result;
18201
18202   //argout typemap for const std::string&
18203
18204   return jresult;
18205 }
18206
18207
18208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18209   int jresult ;
18210   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18211   std::string *arg2 = 0 ;
18212   Dali::Property::Value *arg3 = 0 ;
18213   Dali::Property::AccessMode arg4 ;
18214   Dali::Property::Index result;
18215
18216   arg1 = (Dali::Handle *)jarg1;
18217   if (!jarg2) {
18218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18219     return 0;
18220   }
18221   std::string arg2_str(jarg2);
18222   arg2 = &arg2_str;
18223   arg3 = (Dali::Property::Value *)jarg3;
18224   if (!arg3) {
18225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18226     return 0;
18227   }
18228   arg4 = (Dali::Property::AccessMode)jarg4;
18229   {
18230     try {
18231       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18232     } catch (std::out_of_range& e) {
18233       {
18234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18235       };
18236     } catch (std::exception& e) {
18237       {
18238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (...) {
18241       {
18242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18243       };
18244     }
18245   }
18246   jresult = result;
18247
18248   //argout typemap for const std::string&
18249
18250   return jresult;
18251 }
18252
18253
18254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18255   void * jresult ;
18256   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18257   Dali::Property::Index arg2 ;
18258   Dali::Property::Value result;
18259
18260   arg1 = (Dali::Handle *)jarg1;
18261   arg2 = (Dali::Property::Index)jarg2;
18262   {
18263     try {
18264       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18265     } catch (std::out_of_range& e) {
18266       {
18267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18268       };
18269     } catch (std::exception& e) {
18270       {
18271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18272       };
18273     } catch (...) {
18274       {
18275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18276       };
18277     }
18278   }
18279   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18280   return jresult;
18281 }
18282
18283
18284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18285   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18286   Dali::Property::IndexContainer *arg2 = 0 ;
18287
18288   arg1 = (Dali::Handle *)jarg1;
18289   arg2 = (Dali::Property::IndexContainer *)jarg2;
18290   if (!arg2) {
18291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18292     return ;
18293   }
18294   {
18295     try {
18296       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18297     } catch (std::out_of_range& e) {
18298       {
18299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18300       };
18301     } catch (std::exception& e) {
18302       {
18303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18304       };
18305     } catch (...) {
18306       {
18307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18308       };
18309     }
18310   }
18311 }
18312
18313
18314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18315   void * jresult ;
18316   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18317   Dali::Property::Index arg2 ;
18318   Dali::PropertyCondition *arg3 = 0 ;
18319   Dali::PropertyNotification result;
18320
18321   arg1 = (Dali::Handle *)jarg1;
18322   arg2 = (Dali::Property::Index)jarg2;
18323   arg3 = (Dali::PropertyCondition *)jarg3;
18324   if (!arg3) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18326     return 0;
18327   }
18328   {
18329     try {
18330       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (...) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18342       };
18343     }
18344   }
18345   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18346   return jresult;
18347 }
18348
18349
18350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18351   void * jresult ;
18352   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18353   Dali::Property::Index arg2 ;
18354   int arg3 ;
18355   Dali::PropertyCondition *arg4 = 0 ;
18356   Dali::PropertyNotification result;
18357
18358   arg1 = (Dali::Handle *)jarg1;
18359   arg2 = (Dali::Property::Index)jarg2;
18360   arg3 = (int)jarg3;
18361   arg4 = (Dali::PropertyCondition *)jarg4;
18362   if (!arg4) {
18363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18364     return 0;
18365   }
18366   {
18367     try {
18368       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18369     } catch (std::out_of_range& e) {
18370       {
18371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (std::exception& e) {
18374       {
18375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (...) {
18378       {
18379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18380       };
18381     }
18382   }
18383   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18384   return jresult;
18385 }
18386
18387
18388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18389   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18390   Dali::PropertyNotification arg2 ;
18391   Dali::PropertyNotification *argp2 ;
18392
18393   arg1 = (Dali::Handle *)jarg1;
18394   argp2 = (Dali::PropertyNotification *)jarg2;
18395   if (!argp2) {
18396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18397     return ;
18398   }
18399   arg2 = *argp2;
18400   {
18401     try {
18402       (arg1)->RemovePropertyNotification(arg2);
18403     } catch (std::out_of_range& e) {
18404       {
18405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18406       };
18407     } catch (std::exception& e) {
18408       {
18409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18410       };
18411     } catch (...) {
18412       {
18413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18414       };
18415     }
18416   }
18417 }
18418
18419
18420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18421   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18422
18423   arg1 = (Dali::Handle *)jarg1;
18424   {
18425     try {
18426       (arg1)->RemovePropertyNotifications();
18427     } catch (std::out_of_range& e) {
18428       {
18429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18430       };
18431     } catch (std::exception& e) {
18432       {
18433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18434       };
18435     } catch (...) {
18436       {
18437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18438       };
18439     }
18440   }
18441 }
18442
18443
18444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18445   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18446
18447   arg1 = (Dali::Handle *)jarg1;
18448   {
18449     try {
18450       (arg1)->RemoveConstraints();
18451     } catch (std::out_of_range& e) {
18452       {
18453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18454       };
18455     } catch (std::exception& e) {
18456       {
18457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18458       };
18459     } catch (...) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18462       };
18463     }
18464   }
18465 }
18466
18467
18468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18470   unsigned int arg2 ;
18471
18472   arg1 = (Dali::Handle *)jarg1;
18473   arg2 = (unsigned int)jarg2;
18474   {
18475     try {
18476       (arg1)->RemoveConstraints(arg2);
18477     } catch (std::out_of_range& e) {
18478       {
18479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18480       };
18481     } catch (std::exception& e) {
18482       {
18483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18484       };
18485     } catch (...) {
18486       {
18487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18488       };
18489     }
18490   }
18491 }
18492
18493
18494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18495   int jresult ;
18496   Dali::Property::Index result;
18497
18498   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18499   jresult = result;
18500   return jresult;
18501 }
18502
18503
18504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18505   void * jresult ;
18506   Dali::Handle result;
18507
18508   {
18509     try {
18510       result = Dali::WeightObject::New();
18511     } catch (std::out_of_range& e) {
18512       {
18513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18514       };
18515     } catch (std::exception& e) {
18516       {
18517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18518       };
18519     } catch (...) {
18520       {
18521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18522       };
18523     }
18524   }
18525   jresult = new Dali::Handle((const Dali::Handle &)result);
18526   return jresult;
18527 }
18528
18529
18530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18531   void * jresult ;
18532   Dali::TypeInfo *result = 0 ;
18533
18534   {
18535     try {
18536       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18537     } catch (std::out_of_range& e) {
18538       {
18539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18540       };
18541     } catch (std::exception& e) {
18542       {
18543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18544       };
18545     } catch (...) {
18546       {
18547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18548       };
18549     }
18550   }
18551   jresult = (void *)result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18557   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18558
18559   arg1 = (Dali::TypeInfo *)jarg1;
18560   {
18561     try {
18562       delete arg1;
18563     } catch (std::out_of_range& e) {
18564       {
18565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18566       };
18567     } catch (std::exception& e) {
18568       {
18569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18570       };
18571     } catch (...) {
18572       {
18573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18574       };
18575     }
18576   }
18577 }
18578
18579
18580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18581   void * jresult ;
18582   Dali::TypeInfo *arg1 = 0 ;
18583   Dali::TypeInfo *result = 0 ;
18584
18585   arg1 = (Dali::TypeInfo *)jarg1;
18586   if (!arg1) {
18587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18588     return 0;
18589   }
18590   {
18591     try {
18592       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18593     } catch (std::out_of_range& e) {
18594       {
18595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18596       };
18597     } catch (std::exception& e) {
18598       {
18599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18600       };
18601     } catch (...) {
18602       {
18603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18604       };
18605     }
18606   }
18607   jresult = (void *)result;
18608   return jresult;
18609 }
18610
18611
18612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18613   void * jresult ;
18614   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18615   Dali::TypeInfo *arg2 = 0 ;
18616   Dali::TypeInfo *result = 0 ;
18617
18618   arg1 = (Dali::TypeInfo *)jarg1;
18619   arg2 = (Dali::TypeInfo *)jarg2;
18620   if (!arg2) {
18621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18622     return 0;
18623   }
18624   {
18625     try {
18626       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18627     } catch (std::out_of_range& e) {
18628       {
18629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18630       };
18631     } catch (std::exception& e) {
18632       {
18633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18634       };
18635     } catch (...) {
18636       {
18637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18638       };
18639     }
18640   }
18641   jresult = (void *)result;
18642   return jresult;
18643 }
18644
18645
18646 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18647   char * jresult ;
18648   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18649   std::string *result = 0 ;
18650
18651   arg1 = (Dali::TypeInfo *)jarg1;
18652   {
18653     try {
18654       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18655     } catch (std::out_of_range& e) {
18656       {
18657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (std::exception& e) {
18660       {
18661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18662       };
18663     } catch (...) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18666       };
18667     }
18668   }
18669   jresult = SWIG_csharp_string_callback(result->c_str());
18670   return jresult;
18671 }
18672
18673
18674 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18675   char * jresult ;
18676   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18677   std::string *result = 0 ;
18678
18679   arg1 = (Dali::TypeInfo *)jarg1;
18680   {
18681     try {
18682       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18683     } catch (std::out_of_range& e) {
18684       {
18685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18686       };
18687     } catch (std::exception& e) {
18688       {
18689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18690       };
18691     } catch (...) {
18692       {
18693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18694       };
18695     }
18696   }
18697   jresult = SWIG_csharp_string_callback(result->c_str());
18698   return jresult;
18699 }
18700
18701
18702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18703   void * jresult ;
18704   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18705   Dali::BaseHandle result;
18706
18707   arg1 = (Dali::TypeInfo *)jarg1;
18708   {
18709     try {
18710       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18711     } catch (std::out_of_range& e) {
18712       {
18713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (std::exception& e) {
18716       {
18717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18726   return jresult;
18727 }
18728
18729
18730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18731   unsigned long jresult ;
18732   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18733   size_t result;
18734
18735   arg1 = (Dali::TypeInfo *)jarg1;
18736   {
18737     try {
18738       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18739     } catch (std::out_of_range& e) {
18740       {
18741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (std::exception& e) {
18744       {
18745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18746       };
18747     } catch (...) {
18748       {
18749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18750       };
18751     }
18752   }
18753   jresult = (unsigned long)result;
18754   return jresult;
18755 }
18756
18757
18758 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18759   char * jresult ;
18760   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18761   size_t arg2 ;
18762   std::string result;
18763
18764   arg1 = (Dali::TypeInfo *)jarg1;
18765   arg2 = (size_t)jarg2;
18766   {
18767     try {
18768       result = (arg1)->GetActionName(arg2);
18769     } catch (std::out_of_range& e) {
18770       {
18771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18772       };
18773     } catch (std::exception& e) {
18774       {
18775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (...) {
18778       {
18779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18780       };
18781     }
18782   }
18783   jresult = SWIG_csharp_string_callback((&result)->c_str());
18784   return jresult;
18785 }
18786
18787
18788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18789   unsigned long jresult ;
18790   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18791   size_t result;
18792
18793   arg1 = (Dali::TypeInfo *)jarg1;
18794   {
18795     try {
18796       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18797     } catch (std::out_of_range& e) {
18798       {
18799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18800       };
18801     } catch (std::exception& e) {
18802       {
18803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (...) {
18806       {
18807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18808       };
18809     }
18810   }
18811   jresult = (unsigned long)result;
18812   return jresult;
18813 }
18814
18815
18816 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18817   char * jresult ;
18818   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18819   size_t arg2 ;
18820   std::string result;
18821
18822   arg1 = (Dali::TypeInfo *)jarg1;
18823   arg2 = (size_t)jarg2;
18824   {
18825     try {
18826       result = (arg1)->GetSignalName(arg2);
18827     } catch (std::out_of_range& e) {
18828       {
18829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18830       };
18831     } catch (std::exception& e) {
18832       {
18833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18834       };
18835     } catch (...) {
18836       {
18837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18838       };
18839     }
18840   }
18841   jresult = SWIG_csharp_string_callback((&result)->c_str());
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18847   unsigned long jresult ;
18848   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18849   size_t result;
18850
18851   arg1 = (Dali::TypeInfo *)jarg1;
18852   {
18853     try {
18854       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18855     } catch (std::out_of_range& e) {
18856       {
18857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18858       };
18859     } catch (std::exception& e) {
18860       {
18861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18866       };
18867     }
18868   }
18869   jresult = (unsigned long)result;
18870   return jresult;
18871 }
18872
18873
18874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18875   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18876   Dali::Property::IndexContainer *arg2 = 0 ;
18877
18878   arg1 = (Dali::TypeInfo *)jarg1;
18879   arg2 = (Dali::Property::IndexContainer *)jarg2;
18880   if (!arg2) {
18881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18882     return ;
18883   }
18884   {
18885     try {
18886       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18887     } catch (std::out_of_range& e) {
18888       {
18889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (std::exception& e) {
18892       {
18893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901 }
18902
18903
18904 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18905   char * jresult ;
18906   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18907   Dali::Property::Index arg2 ;
18908   std::string *result = 0 ;
18909
18910   arg1 = (Dali::TypeInfo *)jarg1;
18911   arg2 = (Dali::Property::Index)jarg2;
18912   {
18913     try {
18914       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18922       };
18923     } catch (...) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18926       };
18927     }
18928   }
18929   jresult = SWIG_csharp_string_callback(result->c_str());
18930   return jresult;
18931 }
18932
18933
18934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18935   void * jresult ;
18936   Dali::TypeRegistry result;
18937
18938   {
18939     try {
18940       result = Dali::TypeRegistry::Get();
18941     } catch (std::out_of_range& e) {
18942       {
18943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18944       };
18945     } catch (std::exception& e) {
18946       {
18947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18948       };
18949     } catch (...) {
18950       {
18951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18952       };
18953     }
18954   }
18955   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18956   return jresult;
18957 }
18958
18959
18960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18961   void * jresult ;
18962   Dali::TypeRegistry *result = 0 ;
18963
18964   {
18965     try {
18966       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18967     } catch (std::out_of_range& e) {
18968       {
18969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18970       };
18971     } catch (std::exception& e) {
18972       {
18973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18974       };
18975     } catch (...) {
18976       {
18977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18978       };
18979     }
18980   }
18981   jresult = (void *)result;
18982   return jresult;
18983 }
18984
18985
18986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18987   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18988
18989   arg1 = (Dali::TypeRegistry *)jarg1;
18990   {
18991     try {
18992       delete arg1;
18993     } catch (std::out_of_range& e) {
18994       {
18995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18996       };
18997     } catch (std::exception& e) {
18998       {
18999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19000       };
19001     } catch (...) {
19002       {
19003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19004       };
19005     }
19006   }
19007 }
19008
19009
19010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19011   void * jresult ;
19012   Dali::TypeRegistry *arg1 = 0 ;
19013   Dali::TypeRegistry *result = 0 ;
19014
19015   arg1 = (Dali::TypeRegistry *)jarg1;
19016   if (!arg1) {
19017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19018     return 0;
19019   }
19020   {
19021     try {
19022       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19023     } catch (std::out_of_range& e) {
19024       {
19025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19026       };
19027     } catch (std::exception& e) {
19028       {
19029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19030       };
19031     } catch (...) {
19032       {
19033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19034       };
19035     }
19036   }
19037   jresult = (void *)result;
19038   return jresult;
19039 }
19040
19041
19042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19043   void * jresult ;
19044   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19045   Dali::TypeRegistry *arg2 = 0 ;
19046   Dali::TypeRegistry *result = 0 ;
19047
19048   arg1 = (Dali::TypeRegistry *)jarg1;
19049   arg2 = (Dali::TypeRegistry *)jarg2;
19050   if (!arg2) {
19051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19052     return 0;
19053   }
19054   {
19055     try {
19056       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19057     } catch (std::out_of_range& e) {
19058       {
19059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19060       };
19061     } catch (std::exception& e) {
19062       {
19063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19064       };
19065     } catch (...) {
19066       {
19067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19068       };
19069     }
19070   }
19071   jresult = (void *)result;
19072   return jresult;
19073 }
19074
19075
19076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19077   void * jresult ;
19078   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19079   std::string *arg2 = 0 ;
19080   Dali::TypeInfo result;
19081
19082   arg1 = (Dali::TypeRegistry *)jarg1;
19083   if (!jarg2) {
19084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19085     return 0;
19086   }
19087   std::string arg2_str(jarg2);
19088   arg2 = &arg2_str;
19089   {
19090     try {
19091       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19092     } catch (std::out_of_range& e) {
19093       {
19094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19095       };
19096     } catch (std::exception& e) {
19097       {
19098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19103       };
19104     }
19105   }
19106   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19107
19108   //argout typemap for const std::string&
19109
19110   return jresult;
19111 }
19112
19113
19114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19115   void * jresult ;
19116   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19117   std::type_info *arg2 = 0 ;
19118   Dali::TypeInfo result;
19119
19120   arg1 = (Dali::TypeRegistry *)jarg1;
19121   arg2 = (std::type_info *)jarg2;
19122   if (!arg2) {
19123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19124     return 0;
19125   }
19126   {
19127     try {
19128       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19136       };
19137     } catch (...) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19140       };
19141     }
19142   }
19143   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19144   return jresult;
19145 }
19146
19147
19148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19149   unsigned long jresult ;
19150   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19151   size_t result;
19152
19153   arg1 = (Dali::TypeRegistry *)jarg1;
19154   {
19155     try {
19156       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19168       };
19169     }
19170   }
19171   jresult = (unsigned long)result;
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19177   char * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   size_t arg2 ;
19180   std::string result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   arg2 = (size_t)jarg2;
19184   {
19185     try {
19186       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19187     } catch (std::out_of_range& e) {
19188       {
19189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19190       };
19191     } catch (std::exception& e) {
19192       {
19193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19198       };
19199     }
19200   }
19201   jresult = SWIG_csharp_string_callback((&result)->c_str());
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19207   void * jresult ;
19208   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19209   Dali::TypeRegistry *result = 0 ;
19210
19211   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19212   {
19213     try {
19214       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19215     } catch (std::out_of_range& e) {
19216       {
19217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19218       };
19219     } catch (std::exception& e) {
19220       {
19221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19222       };
19223     } catch (...) {
19224       {
19225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19226       };
19227     }
19228   }
19229   jresult = (void *)result;
19230   return jresult;
19231 }
19232
19233
19234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19235   void * jresult ;
19236   std::type_info *arg1 = 0 ;
19237   std::type_info *arg2 = 0 ;
19238   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19239   Dali::TypeRegistration *result = 0 ;
19240
19241   arg1 = (std::type_info *)jarg1;
19242   if (!arg1) {
19243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19244     return 0;
19245   }
19246   arg2 = (std::type_info *)jarg2;
19247   if (!arg2) {
19248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19249     return 0;
19250   }
19251   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19252   {
19253     try {
19254       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (...) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19266       };
19267     }
19268   }
19269   jresult = (void *)result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19275   void * jresult ;
19276   std::type_info *arg1 = 0 ;
19277   std::type_info *arg2 = 0 ;
19278   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19279   bool arg4 ;
19280   Dali::TypeRegistration *result = 0 ;
19281
19282   arg1 = (std::type_info *)jarg1;
19283   if (!arg1) {
19284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19285     return 0;
19286   }
19287   arg2 = (std::type_info *)jarg2;
19288   if (!arg2) {
19289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19290     return 0;
19291   }
19292   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19293   arg4 = jarg4 ? true : false;
19294   {
19295     try {
19296       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (...) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19308       };
19309     }
19310   }
19311   jresult = (void *)result;
19312   return jresult;
19313 }
19314
19315
19316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19317   void * jresult ;
19318   std::string *arg1 = 0 ;
19319   std::type_info *arg2 = 0 ;
19320   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19321   Dali::TypeRegistration *result = 0 ;
19322
19323   if (!jarg1) {
19324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19325     return 0;
19326   }
19327   std::string arg1_str(jarg1);
19328   arg1 = &arg1_str;
19329   arg2 = (std::type_info *)jarg2;
19330   if (!arg2) {
19331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19332     return 0;
19333   }
19334   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19335   {
19336     try {
19337       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19338     } catch (std::out_of_range& e) {
19339       {
19340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19341       };
19342     } catch (std::exception& e) {
19343       {
19344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19345       };
19346     } catch (...) {
19347       {
19348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19349       };
19350     }
19351   }
19352   jresult = (void *)result;
19353
19354   //argout typemap for const std::string&
19355
19356   return jresult;
19357 }
19358
19359
19360 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19361   char * jresult ;
19362   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19363   std::string result;
19364
19365   arg1 = (Dali::TypeRegistration *)jarg1;
19366   {
19367     try {
19368       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19369     } catch (std::out_of_range& e) {
19370       {
19371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (std::exception& e) {
19374       {
19375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383   jresult = SWIG_csharp_string_callback((&result)->c_str());
19384   return jresult;
19385 }
19386
19387
19388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19389   std::string *arg1 = 0 ;
19390   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19391
19392   if (!jarg1) {
19393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19394     return ;
19395   }
19396   std::string arg1_str(jarg1);
19397   arg1 = &arg1_str;
19398   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19399   {
19400     try {
19401       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19402     } catch (std::out_of_range& e) {
19403       {
19404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19405       };
19406     } catch (std::exception& e) {
19407       {
19408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19409       };
19410     } catch (...) {
19411       {
19412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19413       };
19414     }
19415   }
19416
19417   //argout typemap for const std::string&
19418
19419 }
19420
19421
19422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19423   std::string *arg1 = 0 ;
19424   std::string *arg2 = 0 ;
19425   int arg3 ;
19426   Dali::Property::Type arg4 ;
19427   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19428   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19429
19430   if (!jarg1) {
19431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19432     return ;
19433   }
19434   std::string arg1_str(jarg1);
19435   arg1 = &arg1_str;
19436   if (!jarg2) {
19437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19438     return ;
19439   }
19440   std::string arg2_str(jarg2);
19441   arg2 = &arg2_str;
19442   arg3 = (int)jarg3;
19443   arg4 = (Dali::Property::Type)jarg4;
19444   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19445   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19446   {
19447     try {
19448       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19449     } catch (std::out_of_range& e) {
19450       {
19451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19452       };
19453     } catch (std::exception& e) {
19454       {
19455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19460       };
19461     }
19462   }
19463
19464   //argout typemap for const std::string&
19465
19466
19467   //argout typemap for const std::string&
19468
19469 }
19470
19471
19472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19473   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19474
19475   arg1 = (Dali::TypeRegistration *)jarg1;
19476   {
19477     try {
19478       delete arg1;
19479     } catch (std::out_of_range& e) {
19480       {
19481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19482       };
19483     } catch (std::exception& e) {
19484       {
19485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19486       };
19487     } catch (...) {
19488       {
19489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19490       };
19491     }
19492   }
19493 }
19494
19495
19496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19497   void * jresult ;
19498   Dali::TypeRegistration *arg1 = 0 ;
19499   std::string *arg2 = 0 ;
19500   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19501   Dali::SignalConnectorType *result = 0 ;
19502
19503   arg1 = (Dali::TypeRegistration *)jarg1;
19504   if (!arg1) {
19505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19506     return 0;
19507   }
19508   if (!jarg2) {
19509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19510     return 0;
19511   }
19512   std::string arg2_str(jarg2);
19513   arg2 = &arg2_str;
19514   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19515   {
19516     try {
19517       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19518     } catch (std::out_of_range& e) {
19519       {
19520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19521       };
19522     } catch (std::exception& e) {
19523       {
19524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19525       };
19526     } catch (...) {
19527       {
19528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19529       };
19530     }
19531   }
19532   jresult = (void *)result;
19533
19534   //argout typemap for const std::string&
19535
19536   return jresult;
19537 }
19538
19539
19540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19541   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19542
19543   arg1 = (Dali::SignalConnectorType *)jarg1;
19544   {
19545     try {
19546       delete arg1;
19547     } catch (std::out_of_range& e) {
19548       {
19549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19550       };
19551     } catch (std::exception& e) {
19552       {
19553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19554       };
19555     } catch (...) {
19556       {
19557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19558       };
19559     }
19560   }
19561 }
19562
19563
19564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19565   void * jresult ;
19566   Dali::TypeRegistration *arg1 = 0 ;
19567   std::string *arg2 = 0 ;
19568   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19569   Dali::TypeAction *result = 0 ;
19570
19571   arg1 = (Dali::TypeRegistration *)jarg1;
19572   if (!arg1) {
19573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19574     return 0;
19575   }
19576   if (!jarg2) {
19577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19578     return 0;
19579   }
19580   std::string arg2_str(jarg2);
19581   arg2 = &arg2_str;
19582   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19583   {
19584     try {
19585       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19586     } catch (std::out_of_range& e) {
19587       {
19588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (std::exception& e) {
19591       {
19592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (...) {
19595       {
19596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19597       };
19598     }
19599   }
19600   jresult = (void *)result;
19601
19602   //argout typemap for const std::string&
19603
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19609   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19610
19611   arg1 = (Dali::TypeAction *)jarg1;
19612   {
19613     try {
19614       delete arg1;
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19626       };
19627     }
19628   }
19629 }
19630
19631
19632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19633   void * jresult ;
19634   Dali::TypeRegistration *arg1 = 0 ;
19635   std::string *arg2 = 0 ;
19636   Dali::Property::Index arg3 ;
19637   Dali::Property::Type arg4 ;
19638   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19639   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19640   Dali::PropertyRegistration *result = 0 ;
19641
19642   arg1 = (Dali::TypeRegistration *)jarg1;
19643   if (!arg1) {
19644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19645     return 0;
19646   }
19647   if (!jarg2) {
19648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19649     return 0;
19650   }
19651   std::string arg2_str(jarg2);
19652   arg2 = &arg2_str;
19653   arg3 = (Dali::Property::Index)jarg3;
19654   arg4 = (Dali::Property::Type)jarg4;
19655   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19656   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19657   {
19658     try {
19659       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (...) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19671       };
19672     }
19673   }
19674   jresult = (void *)result;
19675
19676   //argout typemap for const std::string&
19677
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19683   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19684
19685   arg1 = (Dali::PropertyRegistration *)jarg1;
19686   {
19687     try {
19688       delete arg1;
19689     } catch (std::out_of_range& e) {
19690       {
19691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19692       };
19693     } catch (std::exception& e) {
19694       {
19695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19696       };
19697     } catch (...) {
19698       {
19699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19700       };
19701     }
19702   }
19703 }
19704
19705
19706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19707   void * jresult ;
19708   Dali::TypeRegistration *arg1 = 0 ;
19709   std::string *arg2 = 0 ;
19710   Dali::Property::Index arg3 ;
19711   Dali::Property::Type arg4 ;
19712   Dali::AnimatablePropertyRegistration *result = 0 ;
19713
19714   arg1 = (Dali::TypeRegistration *)jarg1;
19715   if (!arg1) {
19716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19717     return 0;
19718   }
19719   if (!jarg2) {
19720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19721     return 0;
19722   }
19723   std::string arg2_str(jarg2);
19724   arg2 = &arg2_str;
19725   arg3 = (Dali::Property::Index)jarg3;
19726   arg4 = (Dali::Property::Type)jarg4;
19727   {
19728     try {
19729       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (...) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19741       };
19742     }
19743   }
19744   jresult = (void *)result;
19745
19746   //argout typemap for const std::string&
19747
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19753   void * jresult ;
19754   Dali::TypeRegistration *arg1 = 0 ;
19755   std::string *arg2 = 0 ;
19756   Dali::Property::Index arg3 ;
19757   Dali::Property::Value *arg4 = 0 ;
19758   Dali::AnimatablePropertyRegistration *result = 0 ;
19759
19760   arg1 = (Dali::TypeRegistration *)jarg1;
19761   if (!arg1) {
19762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19763     return 0;
19764   }
19765   if (!jarg2) {
19766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19767     return 0;
19768   }
19769   std::string arg2_str(jarg2);
19770   arg2 = &arg2_str;
19771   arg3 = (Dali::Property::Index)jarg3;
19772   arg4 = (Dali::Property::Value *)jarg4;
19773   if (!arg4) {
19774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19775     return 0;
19776   }
19777   {
19778     try {
19779       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19780     } catch (std::out_of_range& e) {
19781       {
19782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19783       };
19784     } catch (std::exception& e) {
19785       {
19786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19787       };
19788     } catch (...) {
19789       {
19790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19791       };
19792     }
19793   }
19794   jresult = (void *)result;
19795
19796   //argout typemap for const std::string&
19797
19798   return jresult;
19799 }
19800
19801
19802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19803   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19804
19805   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19806   {
19807     try {
19808       delete arg1;
19809     } catch (std::out_of_range& e) {
19810       {
19811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19812       };
19813     } catch (std::exception& e) {
19814       {
19815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19816       };
19817     } catch (...) {
19818       {
19819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19820       };
19821     }
19822   }
19823 }
19824
19825
19826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19827   void * jresult ;
19828   Dali::TypeRegistration *arg1 = 0 ;
19829   std::string *arg2 = 0 ;
19830   Dali::Property::Index arg3 ;
19831   Dali::Property::Index arg4 ;
19832   unsigned int arg5 ;
19833   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19834
19835   arg1 = (Dali::TypeRegistration *)jarg1;
19836   if (!arg1) {
19837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19838     return 0;
19839   }
19840   if (!jarg2) {
19841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19842     return 0;
19843   }
19844   std::string arg2_str(jarg2);
19845   arg2 = &arg2_str;
19846   arg3 = (Dali::Property::Index)jarg3;
19847   arg4 = (Dali::Property::Index)jarg4;
19848   arg5 = (unsigned int)jarg5;
19849   {
19850     try {
19851       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19852     } catch (std::out_of_range& e) {
19853       {
19854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19855       };
19856     } catch (std::exception& e) {
19857       {
19858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19859       };
19860     } catch (...) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19863       };
19864     }
19865   }
19866   jresult = (void *)result;
19867
19868   //argout typemap for const std::string&
19869
19870   return jresult;
19871 }
19872
19873
19874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19875   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19876
19877   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19878   {
19879     try {
19880       delete arg1;
19881     } catch (std::out_of_range& e) {
19882       {
19883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19884       };
19885     } catch (std::exception& e) {
19886       {
19887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19888       };
19889     } catch (...) {
19890       {
19891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19892       };
19893     }
19894   }
19895 }
19896
19897
19898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19899   void * jresult ;
19900   Dali::TypeRegistration *arg1 = 0 ;
19901   std::string *arg2 = 0 ;
19902   Dali::Property::Index arg3 ;
19903   Dali::Property::Type arg4 ;
19904   Dali::ChildPropertyRegistration *result = 0 ;
19905
19906   arg1 = (Dali::TypeRegistration *)jarg1;
19907   if (!arg1) {
19908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19909     return 0;
19910   }
19911   if (!jarg2) {
19912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19913     return 0;
19914   }
19915   std::string arg2_str(jarg2);
19916   arg2 = &arg2_str;
19917   arg3 = (Dali::Property::Index)jarg3;
19918   arg4 = (Dali::Property::Type)jarg4;
19919   {
19920     try {
19921       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19922     } catch (std::out_of_range& e) {
19923       {
19924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19925       };
19926     } catch (std::exception& e) {
19927       {
19928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19929       };
19930     } catch (...) {
19931       {
19932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19933       };
19934     }
19935   }
19936   jresult = (void *)result;
19937
19938   //argout typemap for const std::string&
19939
19940   return jresult;
19941 }
19942
19943
19944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19945   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19946
19947   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19948   {
19949     try {
19950       delete arg1;
19951     } catch (std::out_of_range& e) {
19952       {
19953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19954       };
19955     } catch (std::exception& e) {
19956       {
19957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19958       };
19959     } catch (...) {
19960       {
19961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19962       };
19963     }
19964   }
19965 }
19966
19967
19968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19969   unsigned int jresult ;
19970   std::string *arg1 = 0 ;
19971   std::type_info *arg2 = 0 ;
19972   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19973   bool result;
19974
19975   if (!jarg1) {
19976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19977     return 0;
19978   }
19979   std::string arg1_str(jarg1);
19980   arg1 = &arg1_str;
19981   arg2 = (std::type_info *)jarg2;
19982   if (!arg2) {
19983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19984     return 0;
19985   }
19986   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19987   {
19988     try {
19989       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19990     } catch (std::out_of_range& e) {
19991       {
19992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19993       };
19994     } catch (std::exception& e) {
19995       {
19996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19997       };
19998     } catch (...) {
19999       {
20000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20001       };
20002     }
20003   }
20004   jresult = result;
20005
20006   //argout typemap for const std::string&
20007
20008   return jresult;
20009 }
20010
20011
20012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20013   unsigned int jresult ;
20014   std::string *arg1 = 0 ;
20015   std::string *arg2 = 0 ;
20016   Dali::Property::Index arg3 ;
20017   Dali::Property::Type arg4 ;
20018   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20019   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20020   bool result;
20021
20022   if (!jarg1) {
20023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20024     return 0;
20025   }
20026   std::string arg1_str(jarg1);
20027   arg1 = &arg1_str;
20028   if (!jarg2) {
20029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20030     return 0;
20031   }
20032   std::string arg2_str(jarg2);
20033   arg2 = &arg2_str;
20034   arg3 = (Dali::Property::Index)jarg3;
20035   arg4 = (Dali::Property::Type)jarg4;
20036   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20037   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20038   {
20039     try {
20040       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (...) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20052       };
20053     }
20054   }
20055   jresult = result;
20056
20057   //argout typemap for const std::string&
20058
20059
20060   //argout typemap for const std::string&
20061
20062   return jresult;
20063 }
20064
20065
20066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20067   float jresult ;
20068   float result;
20069
20070   result = (float)(float)Dali::ParentOrigin::TOP;
20071   jresult = result;
20072   return jresult;
20073 }
20074
20075
20076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20077   float jresult ;
20078   float result;
20079
20080   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20081   jresult = result;
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20087   float jresult ;
20088   float result;
20089
20090   result = (float)(float)Dali::ParentOrigin::LEFT;
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20097   float jresult ;
20098   float result;
20099
20100   result = (float)(float)Dali::ParentOrigin::RIGHT;
20101   jresult = result;
20102   return jresult;
20103 }
20104
20105
20106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20107   float jresult ;
20108   float result;
20109
20110   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20111   jresult = result;
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20117   void * jresult ;
20118   Dali::Vector3 *result = 0 ;
20119
20120   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20121   jresult = (void *)result;
20122   return jresult;
20123 }
20124
20125
20126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20127   void * jresult ;
20128   Dali::Vector3 *result = 0 ;
20129
20130   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20131   jresult = (void *)result;
20132   return jresult;
20133 }
20134
20135
20136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20137   void * jresult ;
20138   Dali::Vector3 *result = 0 ;
20139
20140   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20141   jresult = (void *)result;
20142   return jresult;
20143 }
20144
20145
20146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20147   void * jresult ;
20148   Dali::Vector3 *result = 0 ;
20149
20150   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20151   jresult = (void *)result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20157   void * jresult ;
20158   Dali::Vector3 *result = 0 ;
20159
20160   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20161   jresult = (void *)result;
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20167   void * jresult ;
20168   Dali::Vector3 *result = 0 ;
20169
20170   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20171   jresult = (void *)result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20177   void * jresult ;
20178   Dali::Vector3 *result = 0 ;
20179
20180   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20181   jresult = (void *)result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20187   void * jresult ;
20188   Dali::Vector3 *result = 0 ;
20189
20190   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20191   jresult = (void *)result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20197   void * jresult ;
20198   Dali::Vector3 *result = 0 ;
20199
20200   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20201   jresult = (void *)result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20207   float jresult ;
20208   float result;
20209
20210   result = (float)(float)Dali::AnchorPoint::TOP;
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20217   float jresult ;
20218   float result;
20219
20220   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20221   jresult = result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20227   float jresult ;
20228   float result;
20229
20230   result = (float)(float)Dali::AnchorPoint::LEFT;
20231   jresult = result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20237   float jresult ;
20238   float result;
20239
20240   result = (float)(float)Dali::AnchorPoint::RIGHT;
20241   jresult = result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20247   float jresult ;
20248   float result;
20249
20250   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20251   jresult = result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20287   void * jresult ;
20288   Dali::Vector3 *result = 0 ;
20289
20290   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20291   jresult = (void *)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20297   void * jresult ;
20298   Dali::Vector3 *result = 0 ;
20299
20300   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20301   jresult = (void *)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20307   void * jresult ;
20308   Dali::Vector3 *result = 0 ;
20309
20310   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20311   jresult = (void *)result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20317   void * jresult ;
20318   Dali::Vector3 *result = 0 ;
20319
20320   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20321   jresult = (void *)result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20327   void * jresult ;
20328   Dali::Vector3 *result = 0 ;
20329
20330   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20331   jresult = (void *)result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20337   void * jresult ;
20338   Dali::Vector3 *result = 0 ;
20339
20340   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20341   jresult = (void *)result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20347   void * jresult ;
20348   Dali::Vector4 *result = 0 ;
20349
20350   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20357   void * jresult ;
20358   Dali::Vector4 *result = 0 ;
20359
20360   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20367   void * jresult ;
20368   Dali::Vector4 *result = 0 ;
20369
20370   result = (Dali::Vector4 *)&Dali::Color::RED;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20377   void * jresult ;
20378   Dali::Vector4 *result = 0 ;
20379
20380   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20387   void * jresult ;
20388   Dali::Vector4 *result = 0 ;
20389
20390   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20397   void * jresult ;
20398   Dali::Vector4 *result = 0 ;
20399
20400   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20407   void * jresult ;
20408   Dali::Vector4 *result = 0 ;
20409
20410   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20417   void * jresult ;
20418   Dali::Vector4 *result = 0 ;
20419
20420   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20427   void * jresult ;
20428   Dali::Vector4 *result = 0 ;
20429
20430   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20437   float jresult ;
20438   float result;
20439
20440   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20441   jresult = result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20447   float jresult ;
20448   float result;
20449
20450   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20451   jresult = result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20457   float jresult ;
20458   float result;
20459
20460   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20467   float jresult ;
20468   float result;
20469
20470   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20471   jresult = result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20477   float jresult ;
20478   float result;
20479
20480   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20481   jresult = result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20487   float jresult ;
20488   float result;
20489
20490   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20491   jresult = result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20497   float jresult ;
20498   float result;
20499
20500   result = (float)(float)Dali::Math::PI;
20501   jresult = result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20507   float jresult ;
20508   float result;
20509
20510   result = (float)(float)Dali::Math::PI_2;
20511   jresult = result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20517   float jresult ;
20518   float result;
20519
20520   result = (float)(float)Dali::Math::PI_4;
20521   jresult = result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20527   float jresult ;
20528   float result;
20529
20530   result = (float)(float)Dali::Math::PI_OVER_180;
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20547   int jresult ;
20548   Dali::ResizePolicy::Type result;
20549
20550   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20551   jresult = (int)result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20557   unsigned long jresult ;
20558   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20559   Dali::VectorBase::SizeType result;
20560
20561   arg1 = (Dali::VectorBase *)jarg1;
20562   {
20563     try {
20564       result = ((Dali::VectorBase const *)arg1)->Count();
20565     } catch (std::out_of_range& e) {
20566       {
20567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20568       };
20569     } catch (std::exception& e) {
20570       {
20571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20572       };
20573     } catch (...) {
20574       {
20575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20576       };
20577     }
20578   }
20579   jresult = (unsigned long)result;
20580   return jresult;
20581 }
20582
20583
20584 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20585   unsigned long jresult ;
20586   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20587   Dali::VectorBase::SizeType result;
20588
20589   arg1 = (Dali::VectorBase *)jarg1;
20590   {
20591     try {
20592       result = ((Dali::VectorBase const *)arg1)->Size();
20593     } catch (std::out_of_range& e) {
20594       {
20595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (std::exception& e) {
20598       {
20599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607   jresult = (unsigned long)result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20613   unsigned int jresult ;
20614   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20615   bool result;
20616
20617   arg1 = (Dali::VectorBase *)jarg1;
20618   {
20619     try {
20620       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20621     } catch (std::out_of_range& e) {
20622       {
20623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20624       };
20625     } catch (std::exception& e) {
20626       {
20627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (...) {
20630       {
20631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20632       };
20633     }
20634   }
20635   jresult = result;
20636   return jresult;
20637 }
20638
20639
20640 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20641   unsigned long jresult ;
20642   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20643   Dali::VectorBase::SizeType result;
20644
20645   arg1 = (Dali::VectorBase *)jarg1;
20646   {
20647     try {
20648       result = ((Dali::VectorBase const *)arg1)->Capacity();
20649     } catch (std::out_of_range& e) {
20650       {
20651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (std::exception& e) {
20654       {
20655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20656       };
20657     } catch (...) {
20658       {
20659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20660       };
20661     }
20662   }
20663   jresult = (unsigned long)result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20669   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20670
20671   arg1 = (Dali::VectorBase *)jarg1;
20672   {
20673     try {
20674       (arg1)->Release();
20675     } catch (std::out_of_range& e) {
20676       {
20677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20678       };
20679     } catch (std::exception& e) {
20680       {
20681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20682       };
20683     } catch (...) {
20684       {
20685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20686       };
20687     }
20688   }
20689 }
20690
20691
20692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20693   void * jresult ;
20694   Dali::Image *result = 0 ;
20695
20696   {
20697     try {
20698       result = (Dali::Image *)new Dali::Image();
20699     } catch (std::out_of_range& e) {
20700       {
20701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (std::exception& e) {
20704       {
20705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713   jresult = (void *)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20719   Dali::Image *arg1 = (Dali::Image *) 0 ;
20720
20721   arg1 = (Dali::Image *)jarg1;
20722   {
20723     try {
20724       delete arg1;
20725     } catch (std::out_of_range& e) {
20726       {
20727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20728       };
20729     } catch (std::exception& e) {
20730       {
20731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20732       };
20733     } catch (...) {
20734       {
20735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20736       };
20737     }
20738   }
20739 }
20740
20741
20742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20743   void * jresult ;
20744   Dali::Image *arg1 = 0 ;
20745   Dali::Image *result = 0 ;
20746
20747   arg1 = (Dali::Image *)jarg1;
20748   if (!arg1) {
20749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20750     return 0;
20751   }
20752   {
20753     try {
20754       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20762       };
20763     } catch (...) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20766       };
20767     }
20768   }
20769   jresult = (void *)result;
20770   return jresult;
20771 }
20772
20773
20774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20775   void * jresult ;
20776   Dali::Image *arg1 = (Dali::Image *) 0 ;
20777   Dali::Image *arg2 = 0 ;
20778   Dali::Image *result = 0 ;
20779
20780   arg1 = (Dali::Image *)jarg1;
20781   arg2 = (Dali::Image *)jarg2;
20782   if (!arg2) {
20783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20784     return 0;
20785   }
20786   {
20787     try {
20788       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20789     } catch (std::out_of_range& e) {
20790       {
20791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20792       };
20793     } catch (std::exception& e) {
20794       {
20795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20796       };
20797     } catch (...) {
20798       {
20799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20800       };
20801     }
20802   }
20803   jresult = (void *)result;
20804   return jresult;
20805 }
20806
20807
20808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20809   void * jresult ;
20810   Dali::BaseHandle arg1 ;
20811   Dali::BaseHandle *argp1 ;
20812   Dali::Image result;
20813
20814   argp1 = (Dali::BaseHandle *)jarg1;
20815   if (!argp1) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20817     return 0;
20818   }
20819   arg1 = *argp1;
20820   {
20821     try {
20822       result = Dali::Image::DownCast(arg1);
20823     } catch (std::out_of_range& e) {
20824       {
20825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20826       };
20827     } catch (std::exception& e) {
20828       {
20829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (...) {
20832       {
20833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20834       };
20835     }
20836   }
20837   jresult = new Dali::Image((const Dali::Image &)result);
20838   return jresult;
20839 }
20840
20841
20842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20843   unsigned int jresult ;
20844   Dali::Image *arg1 = (Dali::Image *) 0 ;
20845   unsigned int result;
20846
20847   arg1 = (Dali::Image *)jarg1;
20848   {
20849     try {
20850       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20851     } catch (std::out_of_range& e) {
20852       {
20853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (std::exception& e) {
20856       {
20857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (...) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20862       };
20863     }
20864   }
20865   jresult = result;
20866   return jresult;
20867 }
20868
20869
20870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20871   unsigned int jresult ;
20872   Dali::Image *arg1 = (Dali::Image *) 0 ;
20873   unsigned int result;
20874
20875   arg1 = (Dali::Image *)jarg1;
20876   {
20877     try {
20878       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20879     } catch (std::out_of_range& e) {
20880       {
20881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20882       };
20883     } catch (std::exception& e) {
20884       {
20885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20886       };
20887     } catch (...) {
20888       {
20889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20890       };
20891     }
20892   }
20893   jresult = result;
20894   return jresult;
20895 }
20896
20897
20898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20899   void * jresult ;
20900   Dali::Image *arg1 = (Dali::Image *) 0 ;
20901   Dali::Image::ImageSignalType *result = 0 ;
20902
20903   arg1 = (Dali::Image *)jarg1;
20904   {
20905     try {
20906       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20907     } catch (std::out_of_range& e) {
20908       {
20909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20910       };
20911     } catch (std::exception& e) {
20912       {
20913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20918       };
20919     }
20920   }
20921   jresult = (void *)result;
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20927   int jresult ;
20928   Dali::Pixel::Format result;
20929
20930   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20931   jresult = (int)result;
20932   return jresult;
20933 }
20934
20935
20936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20937   int jresult ;
20938   Dali::Pixel::Format result;
20939
20940   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20941   jresult = (int)result;
20942   return jresult;
20943 }
20944
20945
20946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20947   unsigned int jresult ;
20948   Dali::Pixel::Format arg1 ;
20949   bool result;
20950
20951   arg1 = (Dali::Pixel::Format)jarg1;
20952   {
20953     try {
20954       result = (bool)Dali::Pixel::HasAlpha(arg1);
20955     } catch (std::out_of_range& e) {
20956       {
20957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (std::exception& e) {
20960       {
20961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20962       };
20963     } catch (...) {
20964       {
20965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20966       };
20967     }
20968   }
20969   jresult = result;
20970   return jresult;
20971 }
20972
20973
20974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20975   unsigned int jresult ;
20976   Dali::Pixel::Format arg1 ;
20977   unsigned int result;
20978
20979   arg1 = (Dali::Pixel::Format)jarg1;
20980   {
20981     try {
20982       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20983     } catch (std::out_of_range& e) {
20984       {
20985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (std::exception& e) {
20988       {
20989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (...) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20994       };
20995     }
20996   }
20997   jresult = result;
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21003   Dali::Pixel::Format arg1 ;
21004   int *arg2 = 0 ;
21005   int *arg3 = 0 ;
21006
21007   arg1 = (Dali::Pixel::Format)jarg1;
21008   arg2 = (int *)jarg2;
21009   if (!arg2) {
21010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21011     return ;
21012   }
21013   arg3 = (int *)jarg3;
21014   if (!arg3) {
21015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21016     return ;
21017   }
21018   {
21019     try {
21020       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21028       };
21029     } catch (...) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21032       };
21033     }
21034   }
21035 }
21036
21037
21038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21039   void * jresult ;
21040   unsigned char *arg1 = (unsigned char *) 0 ;
21041   unsigned int arg2 ;
21042   unsigned int arg3 ;
21043   unsigned int arg4 ;
21044   Dali::Pixel::Format arg5 ;
21045   Dali::PixelData::ReleaseFunction arg6 ;
21046   Dali::PixelData result;
21047
21048   arg1 = jarg1;
21049   arg2 = (unsigned int)jarg2;
21050   arg3 = (unsigned int)jarg3;
21051   arg4 = (unsigned int)jarg4;
21052   arg5 = (Dali::Pixel::Format)jarg5;
21053   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21054   {
21055     try {
21056       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21057     } catch (std::out_of_range& e) {
21058       {
21059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21060       };
21061     } catch (std::exception& e) {
21062       {
21063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21068       };
21069     }
21070   }
21071   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21072
21073
21074   return jresult;
21075 }
21076
21077
21078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21079   void * jresult ;
21080   Dali::PixelData *result = 0 ;
21081
21082   {
21083     try {
21084       result = (Dali::PixelData *)new Dali::PixelData();
21085     } catch (std::out_of_range& e) {
21086       {
21087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21088       };
21089     } catch (std::exception& e) {
21090       {
21091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21096       };
21097     }
21098   }
21099   jresult = (void *)result;
21100   return jresult;
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21106
21107   arg1 = (Dali::PixelData *)jarg1;
21108   {
21109     try {
21110       delete arg1;
21111     } catch (std::out_of_range& e) {
21112       {
21113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21114       };
21115     } catch (std::exception& e) {
21116       {
21117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (...) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21122       };
21123     }
21124   }
21125 }
21126
21127
21128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21129   void * jresult ;
21130   Dali::PixelData *arg1 = 0 ;
21131   Dali::PixelData *result = 0 ;
21132
21133   arg1 = (Dali::PixelData *)jarg1;
21134   if (!arg1) {
21135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21136     return 0;
21137   }
21138   {
21139     try {
21140       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21141     } catch (std::out_of_range& e) {
21142       {
21143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21144       };
21145     } catch (std::exception& e) {
21146       {
21147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21148       };
21149     } catch (...) {
21150       {
21151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21152       };
21153     }
21154   }
21155   jresult = (void *)result;
21156   return jresult;
21157 }
21158
21159
21160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21161   void * jresult ;
21162   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21163   Dali::PixelData *arg2 = 0 ;
21164   Dali::PixelData *result = 0 ;
21165
21166   arg1 = (Dali::PixelData *)jarg1;
21167   arg2 = (Dali::PixelData *)jarg2;
21168   if (!arg2) {
21169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21170     return 0;
21171   }
21172   {
21173     try {
21174       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21175     } catch (std::out_of_range& e) {
21176       {
21177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21178       };
21179     } catch (std::exception& e) {
21180       {
21181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21182       };
21183     } catch (...) {
21184       {
21185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21186       };
21187     }
21188   }
21189   jresult = (void *)result;
21190   return jresult;
21191 }
21192
21193
21194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21195   unsigned int jresult ;
21196   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21197   unsigned int result;
21198
21199   arg1 = (Dali::PixelData *)jarg1;
21200   {
21201     try {
21202       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21203     } catch (std::out_of_range& e) {
21204       {
21205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21206       };
21207     } catch (std::exception& e) {
21208       {
21209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21210       };
21211     } catch (...) {
21212       {
21213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21214       };
21215     }
21216   }
21217   jresult = result;
21218   return jresult;
21219 }
21220
21221
21222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21223   unsigned int jresult ;
21224   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21225   unsigned int result;
21226
21227   arg1 = (Dali::PixelData *)jarg1;
21228   {
21229     try {
21230       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21231     } catch (std::out_of_range& e) {
21232       {
21233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21234       };
21235     } catch (std::exception& e) {
21236       {
21237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21238       };
21239     } catch (...) {
21240       {
21241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21242       };
21243     }
21244   }
21245   jresult = result;
21246   return jresult;
21247 }
21248
21249
21250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21251   int jresult ;
21252   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21253   Dali::Pixel::Format result;
21254
21255   arg1 = (Dali::PixelData *)jarg1;
21256   {
21257     try {
21258       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21259     } catch (std::out_of_range& e) {
21260       {
21261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21262       };
21263     } catch (std::exception& e) {
21264       {
21265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21266       };
21267     } catch (...) {
21268       {
21269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21270       };
21271     }
21272   }
21273   jresult = (int)result;
21274   return jresult;
21275 }
21276
21277
21278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21279   unsigned int jresult ;
21280   unsigned int result;
21281
21282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21283   jresult = result;
21284   return jresult;
21285 }
21286
21287
21288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21289   unsigned int jresult ;
21290   unsigned int result;
21291
21292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21293   jresult = result;
21294   return jresult;
21295 }
21296
21297
21298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21299   unsigned int jresult ;
21300   unsigned int result;
21301
21302   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21303   jresult = result;
21304   return jresult;
21305 }
21306
21307
21308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21309   unsigned int jresult ;
21310   unsigned int result;
21311
21312   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21313   jresult = result;
21314   return jresult;
21315 }
21316
21317
21318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21319   unsigned int jresult ;
21320   unsigned int result;
21321
21322   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21323   jresult = result;
21324   return jresult;
21325 }
21326
21327
21328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21329   unsigned int jresult ;
21330   unsigned int result;
21331
21332   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21333   jresult = result;
21334   return jresult;
21335 }
21336
21337
21338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21339   void * jresult ;
21340   Dali::TextureType::Type arg1 ;
21341   Dali::Pixel::Format arg2 ;
21342   unsigned int arg3 ;
21343   unsigned int arg4 ;
21344   Dali::Texture result;
21345
21346   arg1 = (Dali::TextureType::Type)jarg1;
21347   arg2 = (Dali::Pixel::Format)jarg2;
21348   arg3 = (unsigned int)jarg3;
21349   arg4 = (unsigned int)jarg4;
21350   {
21351     try {
21352       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (...) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21364       };
21365     }
21366   }
21367   jresult = new Dali::Texture((const Dali::Texture &)result);
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21373   void * jresult ;
21374   NativeImageInterface *arg1 = 0 ;
21375   Dali::Texture result;
21376
21377   arg1 = (NativeImageInterface *)jarg1;
21378   if (!arg1) {
21379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21380     return 0;
21381   }
21382   {
21383     try {
21384       result = Dali::Texture::New(*arg1);
21385     } catch (std::out_of_range& e) {
21386       {
21387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (std::exception& e) {
21390       {
21391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (...) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21396       };
21397     }
21398   }
21399   jresult = new Dali::Texture((const Dali::Texture &)result);
21400   return jresult;
21401 }
21402
21403
21404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21405   void * jresult ;
21406   Dali::Texture *result = 0 ;
21407
21408   {
21409     try {
21410       result = (Dali::Texture *)new Dali::Texture();
21411     } catch (std::out_of_range& e) {
21412       {
21413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21414       };
21415     } catch (std::exception& e) {
21416       {
21417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21418       };
21419     } catch (...) {
21420       {
21421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21422       };
21423     }
21424   }
21425   jresult = (void *)result;
21426   return jresult;
21427 }
21428
21429
21430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21431   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21432
21433   arg1 = (Dali::Texture *)jarg1;
21434   {
21435     try {
21436       delete arg1;
21437     } catch (std::out_of_range& e) {
21438       {
21439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21440       };
21441     } catch (std::exception& e) {
21442       {
21443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21444       };
21445     } catch (...) {
21446       {
21447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21448       };
21449     }
21450   }
21451 }
21452
21453
21454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21455   void * jresult ;
21456   Dali::Texture *arg1 = 0 ;
21457   Dali::Texture *result = 0 ;
21458
21459   arg1 = (Dali::Texture *)jarg1;
21460   if (!arg1) {
21461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21462     return 0;
21463   }
21464   {
21465     try {
21466       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21467     } catch (std::out_of_range& e) {
21468       {
21469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21470       };
21471     } catch (std::exception& e) {
21472       {
21473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21474       };
21475     } catch (...) {
21476       {
21477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21478       };
21479     }
21480   }
21481   jresult = (void *)result;
21482   return jresult;
21483 }
21484
21485
21486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21487   void * jresult ;
21488   Dali::BaseHandle arg1 ;
21489   Dali::BaseHandle *argp1 ;
21490   Dali::Texture result;
21491
21492   argp1 = (Dali::BaseHandle *)jarg1;
21493   if (!argp1) {
21494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21495     return 0;
21496   }
21497   arg1 = *argp1;
21498   {
21499     try {
21500       result = Dali::Texture::DownCast(arg1);
21501     } catch (std::out_of_range& e) {
21502       {
21503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21504       };
21505     } catch (std::exception& e) {
21506       {
21507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21508       };
21509     } catch (...) {
21510       {
21511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21512       };
21513     }
21514   }
21515   jresult = new Dali::Texture((const Dali::Texture &)result);
21516   return jresult;
21517 }
21518
21519
21520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21521   void * jresult ;
21522   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21523   Dali::Texture *arg2 = 0 ;
21524   Dali::Texture *result = 0 ;
21525
21526   arg1 = (Dali::Texture *)jarg1;
21527   arg2 = (Dali::Texture *)jarg2;
21528   if (!arg2) {
21529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21530     return 0;
21531   }
21532   {
21533     try {
21534       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21535     } catch (std::out_of_range& e) {
21536       {
21537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21538       };
21539     } catch (std::exception& e) {
21540       {
21541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21542       };
21543     } catch (...) {
21544       {
21545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21546       };
21547     }
21548   }
21549   jresult = (void *)result;
21550   return jresult;
21551 }
21552
21553
21554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21555   unsigned int jresult ;
21556   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21557   Dali::PixelData arg2 ;
21558   Dali::PixelData *argp2 ;
21559   bool result;
21560
21561   arg1 = (Dali::Texture *)jarg1;
21562   argp2 = (Dali::PixelData *)jarg2;
21563   if (!argp2) {
21564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21565     return 0;
21566   }
21567   arg2 = *argp2;
21568   {
21569     try {
21570       result = (bool)(arg1)->Upload(arg2);
21571     } catch (std::out_of_range& e) {
21572       {
21573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (std::exception& e) {
21576       {
21577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21578       };
21579     } catch (...) {
21580       {
21581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21582       };
21583     }
21584   }
21585   jresult = result;
21586   return jresult;
21587 }
21588
21589
21590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
21591   unsigned int jresult ;
21592   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21593   Dali::PixelData arg2 ;
21594   unsigned int arg3 ;
21595   unsigned int arg4 ;
21596   unsigned int arg5 ;
21597   unsigned int arg6 ;
21598   unsigned int arg7 ;
21599   unsigned int arg8 ;
21600   Dali::PixelData *argp2 ;
21601   bool result;
21602
21603   arg1 = (Dali::Texture *)jarg1;
21604   argp2 = (Dali::PixelData *)jarg2;
21605   if (!argp2) {
21606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21607     return 0;
21608   }
21609   arg2 = *argp2;
21610   arg3 = (unsigned int)jarg3;
21611   arg4 = (unsigned int)jarg4;
21612   arg5 = (unsigned int)jarg5;
21613   arg6 = (unsigned int)jarg6;
21614   arg7 = (unsigned int)jarg7;
21615   arg8 = (unsigned int)jarg8;
21616   {
21617     try {
21618       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21619     } catch (std::out_of_range& e) {
21620       {
21621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21622       };
21623     } catch (std::exception& e) {
21624       {
21625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21626       };
21627     } catch (...) {
21628       {
21629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21630       };
21631     }
21632   }
21633   jresult = result;
21634   return jresult;
21635 }
21636
21637
21638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21639   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21640
21641   arg1 = (Dali::Texture *)jarg1;
21642   {
21643     try {
21644       (arg1)->GenerateMipmaps();
21645     } catch (std::out_of_range& e) {
21646       {
21647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21648       };
21649     } catch (std::exception& e) {
21650       {
21651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21652       };
21653     } catch (...) {
21654       {
21655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21656       };
21657     }
21658   }
21659 }
21660
21661
21662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21663   unsigned int jresult ;
21664   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21665   unsigned int result;
21666
21667   arg1 = (Dali::Texture *)jarg1;
21668   {
21669     try {
21670       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21682       };
21683     }
21684   }
21685   jresult = result;
21686   return jresult;
21687 }
21688
21689
21690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21691   unsigned int jresult ;
21692   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21693   unsigned int result;
21694
21695   arg1 = (Dali::Texture *)jarg1;
21696   {
21697     try {
21698       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21699     } catch (std::out_of_range& e) {
21700       {
21701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (std::exception& e) {
21704       {
21705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713   jresult = result;
21714   return jresult;
21715 }
21716
21717
21718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21719   void * jresult ;
21720   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21721   Dali::Texture *result = 0 ;
21722
21723   arg1 = (Dali::Internal::Texture *)jarg1;
21724   {
21725     try {
21726       result = (Dali::Texture *)new Dali::Texture(arg1);
21727     } catch (std::out_of_range& e) {
21728       {
21729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21730       };
21731     } catch (std::exception& e) {
21732       {
21733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21734       };
21735     } catch (...) {
21736       {
21737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21738       };
21739     }
21740   }
21741   jresult = (void *)result;
21742   return jresult;
21743 }
21744
21745
21746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21747   void * jresult ;
21748   Dali::Sampler result;
21749
21750   {
21751     try {
21752       result = Dali::Sampler::New();
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (...) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21764       };
21765     }
21766   }
21767   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21768   return jresult;
21769 }
21770
21771
21772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21773   void * jresult ;
21774   Dali::Sampler *result = 0 ;
21775
21776   {
21777     try {
21778       result = (Dali::Sampler *)new Dali::Sampler();
21779     } catch (std::out_of_range& e) {
21780       {
21781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (std::exception& e) {
21784       {
21785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21790       };
21791     }
21792   }
21793   jresult = (void *)result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21799   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21800
21801   arg1 = (Dali::Sampler *)jarg1;
21802   {
21803     try {
21804       delete arg1;
21805     } catch (std::out_of_range& e) {
21806       {
21807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21808       };
21809     } catch (std::exception& e) {
21810       {
21811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21812       };
21813     } catch (...) {
21814       {
21815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21816       };
21817     }
21818   }
21819 }
21820
21821
21822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21823   void * jresult ;
21824   Dali::Sampler *arg1 = 0 ;
21825   Dali::Sampler *result = 0 ;
21826
21827   arg1 = (Dali::Sampler *)jarg1;
21828   if (!arg1) {
21829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21830     return 0;
21831   }
21832   {
21833     try {
21834       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (...) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21846       };
21847     }
21848   }
21849   jresult = (void *)result;
21850   return jresult;
21851 }
21852
21853
21854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21855   void * jresult ;
21856   Dali::BaseHandle arg1 ;
21857   Dali::BaseHandle *argp1 ;
21858   Dali::Sampler result;
21859
21860   argp1 = (Dali::BaseHandle *)jarg1;
21861   if (!argp1) {
21862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21863     return 0;
21864   }
21865   arg1 = *argp1;
21866   {
21867     try {
21868       result = Dali::Sampler::DownCast(arg1);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (...) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21880       };
21881     }
21882   }
21883   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21884   return jresult;
21885 }
21886
21887
21888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21889   void * jresult ;
21890   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21891   Dali::Sampler *arg2 = 0 ;
21892   Dali::Sampler *result = 0 ;
21893
21894   arg1 = (Dali::Sampler *)jarg1;
21895   arg2 = (Dali::Sampler *)jarg2;
21896   if (!arg2) {
21897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21898     return 0;
21899   }
21900   {
21901     try {
21902       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21903     } catch (std::out_of_range& e) {
21904       {
21905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21906       };
21907     } catch (std::exception& e) {
21908       {
21909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (...) {
21912       {
21913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21914       };
21915     }
21916   }
21917   jresult = (void *)result;
21918   return jresult;
21919 }
21920
21921
21922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21923   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21924   Dali::FilterMode::Type arg2 ;
21925   Dali::FilterMode::Type arg3 ;
21926
21927   arg1 = (Dali::Sampler *)jarg1;
21928   arg2 = (Dali::FilterMode::Type)jarg2;
21929   arg3 = (Dali::FilterMode::Type)jarg3;
21930   {
21931     try {
21932       (arg1)->SetFilterMode(arg2,arg3);
21933     } catch (std::out_of_range& e) {
21934       {
21935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21936       };
21937     } catch (std::exception& e) {
21938       {
21939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21940       };
21941     } catch (...) {
21942       {
21943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21944       };
21945     }
21946   }
21947 }
21948
21949
21950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21951   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21952   Dali::WrapMode::Type arg2 ;
21953   Dali::WrapMode::Type arg3 ;
21954
21955   arg1 = (Dali::Sampler *)jarg1;
21956   arg2 = (Dali::WrapMode::Type)jarg2;
21957   arg3 = (Dali::WrapMode::Type)jarg3;
21958   {
21959     try {
21960       (arg1)->SetWrapMode(arg2,arg3);
21961     } catch (std::out_of_range& e) {
21962       {
21963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21964       };
21965     } catch (std::exception& e) {
21966       {
21967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21968       };
21969     } catch (...) {
21970       {
21971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21972       };
21973     }
21974   }
21975 }
21976
21977
21978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21979   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21980   Dali::WrapMode::Type arg2 ;
21981   Dali::WrapMode::Type arg3 ;
21982   Dali::WrapMode::Type arg4 ;
21983
21984   arg1 = (Dali::Sampler *)jarg1;
21985   arg2 = (Dali::WrapMode::Type)jarg2;
21986   arg3 = (Dali::WrapMode::Type)jarg3;
21987   arg4 = (Dali::WrapMode::Type)jarg4;
21988   {
21989     try {
21990       (arg1)->SetWrapMode(arg2,arg3,arg4);
21991     } catch (std::out_of_range& e) {
21992       {
21993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21994       };
21995     } catch (std::exception& e) {
21996       {
21997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22002       };
22003     }
22004   }
22005 }
22006
22007
22008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22009   void * jresult ;
22010   Dali::TextureSet result;
22011
22012   {
22013     try {
22014       result = Dali::TextureSet::New();
22015     } catch (std::out_of_range& e) {
22016       {
22017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22018       };
22019     } catch (std::exception& e) {
22020       {
22021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (...) {
22024       {
22025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22026       };
22027     }
22028   }
22029   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22035   void * jresult ;
22036   Dali::TextureSet *result = 0 ;
22037
22038   {
22039     try {
22040       result = (Dali::TextureSet *)new Dali::TextureSet();
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055   jresult = (void *)result;
22056   return jresult;
22057 }
22058
22059
22060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22061   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22062
22063   arg1 = (Dali::TextureSet *)jarg1;
22064   {
22065     try {
22066       delete arg1;
22067     } catch (std::out_of_range& e) {
22068       {
22069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22070       };
22071     } catch (std::exception& e) {
22072       {
22073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22074       };
22075     } catch (...) {
22076       {
22077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22078       };
22079     }
22080   }
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22085   void * jresult ;
22086   Dali::TextureSet *arg1 = 0 ;
22087   Dali::TextureSet *result = 0 ;
22088
22089   arg1 = (Dali::TextureSet *)jarg1;
22090   if (!arg1) {
22091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22092     return 0;
22093   }
22094   {
22095     try {
22096       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22097     } catch (std::out_of_range& e) {
22098       {
22099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22100       };
22101     } catch (std::exception& e) {
22102       {
22103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22104       };
22105     } catch (...) {
22106       {
22107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22108       };
22109     }
22110   }
22111   jresult = (void *)result;
22112   return jresult;
22113 }
22114
22115
22116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22117   void * jresult ;
22118   Dali::BaseHandle arg1 ;
22119   Dali::BaseHandle *argp1 ;
22120   Dali::TextureSet result;
22121
22122   argp1 = (Dali::BaseHandle *)jarg1;
22123   if (!argp1) {
22124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22125     return 0;
22126   }
22127   arg1 = *argp1;
22128   {
22129     try {
22130       result = Dali::TextureSet::DownCast(arg1);
22131     } catch (std::out_of_range& e) {
22132       {
22133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22134       };
22135     } catch (std::exception& e) {
22136       {
22137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22138       };
22139     } catch (...) {
22140       {
22141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22142       };
22143     }
22144   }
22145   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22146   return jresult;
22147 }
22148
22149
22150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22151   void * jresult ;
22152   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22153   Dali::TextureSet *arg2 = 0 ;
22154   Dali::TextureSet *result = 0 ;
22155
22156   arg1 = (Dali::TextureSet *)jarg1;
22157   arg2 = (Dali::TextureSet *)jarg2;
22158   if (!arg2) {
22159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22160     return 0;
22161   }
22162   {
22163     try {
22164       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22165     } catch (std::out_of_range& e) {
22166       {
22167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22168       };
22169     } catch (std::exception& e) {
22170       {
22171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22172       };
22173     } catch (...) {
22174       {
22175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22176       };
22177     }
22178   }
22179   jresult = (void *)result;
22180   return jresult;
22181 }
22182
22183
22184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22185   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22186   size_t arg2 ;
22187   Dali::Texture arg3 ;
22188   Dali::Texture *argp3 ;
22189
22190   arg1 = (Dali::TextureSet *)jarg1;
22191   arg2 = (size_t)jarg2;
22192   argp3 = (Dali::Texture *)jarg3;
22193   if (!argp3) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22195     return ;
22196   }
22197   arg3 = *argp3;
22198   {
22199     try {
22200       (arg1)->SetTexture(arg2,arg3);
22201     } catch (std::out_of_range& e) {
22202       {
22203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22204       };
22205     } catch (std::exception& e) {
22206       {
22207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22208       };
22209     } catch (...) {
22210       {
22211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22212       };
22213     }
22214   }
22215 }
22216
22217
22218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22219   void * jresult ;
22220   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22221   size_t arg2 ;
22222   Dali::Texture result;
22223
22224   arg1 = (Dali::TextureSet *)jarg1;
22225   arg2 = (size_t)jarg2;
22226   {
22227     try {
22228       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22236       };
22237     } catch (...) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22240       };
22241     }
22242   }
22243   jresult = new Dali::Texture((const Dali::Texture &)result);
22244   return jresult;
22245 }
22246
22247
22248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22249   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22250   size_t arg2 ;
22251   Dali::Sampler arg3 ;
22252   Dali::Sampler *argp3 ;
22253
22254   arg1 = (Dali::TextureSet *)jarg1;
22255   arg2 = (size_t)jarg2;
22256   argp3 = (Dali::Sampler *)jarg3;
22257   if (!argp3) {
22258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22259     return ;
22260   }
22261   arg3 = *argp3;
22262   {
22263     try {
22264       (arg1)->SetSampler(arg2,arg3);
22265     } catch (std::out_of_range& e) {
22266       {
22267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22268       };
22269     } catch (std::exception& e) {
22270       {
22271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22276       };
22277     }
22278   }
22279 }
22280
22281
22282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22283   void * jresult ;
22284   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22285   size_t arg2 ;
22286   Dali::Sampler result;
22287
22288   arg1 = (Dali::TextureSet *)jarg1;
22289   arg2 = (size_t)jarg2;
22290   {
22291     try {
22292       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22293     } catch (std::out_of_range& e) {
22294       {
22295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22296       };
22297     } catch (std::exception& e) {
22298       {
22299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22300       };
22301     } catch (...) {
22302       {
22303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22304       };
22305     }
22306   }
22307   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22313   unsigned long jresult ;
22314   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22315   size_t result;
22316
22317   arg1 = (Dali::TextureSet *)jarg1;
22318   {
22319     try {
22320       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22321     } catch (std::out_of_range& e) {
22322       {
22323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22324       };
22325     } catch (std::exception& e) {
22326       {
22327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22328       };
22329     } catch (...) {
22330       {
22331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22332       };
22333     }
22334   }
22335   jresult = (unsigned long)result;
22336   return jresult;
22337 }
22338
22339
22340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22341   void * jresult ;
22342   Dali::Property::Map *arg1 = 0 ;
22343   Dali::PropertyBuffer result;
22344
22345   arg1 = (Dali::Property::Map *)jarg1;
22346   if (!arg1) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22348     return 0;
22349   }
22350   {
22351     try {
22352       result = Dali::PropertyBuffer::New(*arg1);
22353     } catch (std::out_of_range& e) {
22354       {
22355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22356       };
22357     } catch (std::exception& e) {
22358       {
22359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22360       };
22361     } catch (...) {
22362       {
22363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22364       };
22365     }
22366   }
22367   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22368   return jresult;
22369 }
22370
22371
22372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22373   void * jresult ;
22374   Dali::PropertyBuffer *result = 0 ;
22375
22376   {
22377     try {
22378       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22379     } catch (std::out_of_range& e) {
22380       {
22381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22382       };
22383     } catch (std::exception& e) {
22384       {
22385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22386       };
22387     } catch (...) {
22388       {
22389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22390       };
22391     }
22392   }
22393   jresult = (void *)result;
22394   return jresult;
22395 }
22396
22397
22398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22399   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22400
22401   arg1 = (Dali::PropertyBuffer *)jarg1;
22402   {
22403     try {
22404       delete arg1;
22405     } catch (std::out_of_range& e) {
22406       {
22407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22408       };
22409     } catch (std::exception& e) {
22410       {
22411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22412       };
22413     } catch (...) {
22414       {
22415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22416       };
22417     }
22418   }
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22423   void * jresult ;
22424   Dali::PropertyBuffer *arg1 = 0 ;
22425   Dali::PropertyBuffer *result = 0 ;
22426
22427   arg1 = (Dali::PropertyBuffer *)jarg1;
22428   if (!arg1) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22430     return 0;
22431   }
22432   {
22433     try {
22434       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22435     } catch (std::out_of_range& e) {
22436       {
22437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22438       };
22439     } catch (std::exception& e) {
22440       {
22441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22442       };
22443     } catch (...) {
22444       {
22445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22446       };
22447     }
22448   }
22449   jresult = (void *)result;
22450   return jresult;
22451 }
22452
22453
22454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22455   void * jresult ;
22456   Dali::BaseHandle arg1 ;
22457   Dali::BaseHandle *argp1 ;
22458   Dali::PropertyBuffer result;
22459
22460   argp1 = (Dali::BaseHandle *)jarg1;
22461   if (!argp1) {
22462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22463     return 0;
22464   }
22465   arg1 = *argp1;
22466   {
22467     try {
22468       result = Dali::PropertyBuffer::DownCast(arg1);
22469     } catch (std::out_of_range& e) {
22470       {
22471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22472       };
22473     } catch (std::exception& e) {
22474       {
22475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22476       };
22477     } catch (...) {
22478       {
22479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22480       };
22481     }
22482   }
22483   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22484   return jresult;
22485 }
22486
22487
22488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22489   void * jresult ;
22490   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22491   Dali::PropertyBuffer *arg2 = 0 ;
22492   Dali::PropertyBuffer *result = 0 ;
22493
22494   arg1 = (Dali::PropertyBuffer *)jarg1;
22495   arg2 = (Dali::PropertyBuffer *)jarg2;
22496   if (!arg2) {
22497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22498     return 0;
22499   }
22500   {
22501     try {
22502       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22503     } catch (std::out_of_range& e) {
22504       {
22505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22506       };
22507     } catch (std::exception& e) {
22508       {
22509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22510       };
22511     } catch (...) {
22512       {
22513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22514       };
22515     }
22516   }
22517   jresult = (void *)result;
22518   return jresult;
22519 }
22520
22521
22522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22523   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22524   void *arg2 = (void *) 0 ;
22525   std::size_t arg3 ;
22526
22527   arg1 = (Dali::PropertyBuffer *)jarg1;
22528   arg2 = jarg2;
22529   arg3 = (std::size_t)jarg3;
22530   {
22531     try {
22532       (arg1)->SetData((void const *)arg2,arg3);
22533     } catch (std::out_of_range& e) {
22534       {
22535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22536       };
22537     } catch (std::exception& e) {
22538       {
22539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22540       };
22541     } catch (...) {
22542       {
22543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22544       };
22545     }
22546   }
22547 }
22548
22549
22550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22551   unsigned long jresult ;
22552   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22553   std::size_t result;
22554
22555   arg1 = (Dali::PropertyBuffer *)jarg1;
22556   {
22557     try {
22558       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22559     } catch (std::out_of_range& e) {
22560       {
22561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22562       };
22563     } catch (std::exception& e) {
22564       {
22565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22566       };
22567     } catch (...) {
22568       {
22569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22570       };
22571     }
22572   }
22573   jresult = (unsigned long)result;
22574   return jresult;
22575 }
22576
22577
22578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22579   void * jresult ;
22580   Dali::Geometry result;
22581
22582   {
22583     try {
22584       result = Dali::Geometry::New();
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (...) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22596       };
22597     }
22598   }
22599   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22600   return jresult;
22601 }
22602
22603
22604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22605   void * jresult ;
22606   Dali::Geometry *result = 0 ;
22607
22608   {
22609     try {
22610       result = (Dali::Geometry *)new Dali::Geometry();
22611     } catch (std::out_of_range& e) {
22612       {
22613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22614       };
22615     } catch (std::exception& e) {
22616       {
22617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22618       };
22619     } catch (...) {
22620       {
22621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22622       };
22623     }
22624   }
22625   jresult = (void *)result;
22626   return jresult;
22627 }
22628
22629
22630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22631   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22632
22633   arg1 = (Dali::Geometry *)jarg1;
22634   {
22635     try {
22636       delete arg1;
22637     } catch (std::out_of_range& e) {
22638       {
22639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (std::exception& e) {
22642       {
22643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22644       };
22645     } catch (...) {
22646       {
22647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22648       };
22649     }
22650   }
22651 }
22652
22653
22654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22655   void * jresult ;
22656   Dali::Geometry *arg1 = 0 ;
22657   Dali::Geometry *result = 0 ;
22658
22659   arg1 = (Dali::Geometry *)jarg1;
22660   if (!arg1) {
22661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22662     return 0;
22663   }
22664   {
22665     try {
22666       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (...) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22678       };
22679     }
22680   }
22681   jresult = (void *)result;
22682   return jresult;
22683 }
22684
22685
22686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22687   void * jresult ;
22688   Dali::BaseHandle arg1 ;
22689   Dali::BaseHandle *argp1 ;
22690   Dali::Geometry result;
22691
22692   argp1 = (Dali::BaseHandle *)jarg1;
22693   if (!argp1) {
22694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22695     return 0;
22696   }
22697   arg1 = *argp1;
22698   {
22699     try {
22700       result = Dali::Geometry::DownCast(arg1);
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22708       };
22709     } catch (...) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22712       };
22713     }
22714   }
22715   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22716   return jresult;
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22721   void * jresult ;
22722   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22723   Dali::Geometry *arg2 = 0 ;
22724   Dali::Geometry *result = 0 ;
22725
22726   arg1 = (Dali::Geometry *)jarg1;
22727   arg2 = (Dali::Geometry *)jarg2;
22728   if (!arg2) {
22729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22730     return 0;
22731   }
22732   {
22733     try {
22734       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22735     } catch (std::out_of_range& e) {
22736       {
22737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22738       };
22739     } catch (std::exception& e) {
22740       {
22741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22742       };
22743     } catch (...) {
22744       {
22745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22746       };
22747     }
22748   }
22749   jresult = (void *)result;
22750   return jresult;
22751 }
22752
22753
22754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22755   unsigned long jresult ;
22756   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22757   Dali::PropertyBuffer *arg2 = 0 ;
22758   std::size_t result;
22759
22760   arg1 = (Dali::Geometry *)jarg1;
22761   arg2 = (Dali::PropertyBuffer *)jarg2;
22762   if (!arg2) {
22763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22764     return 0;
22765   }
22766   {
22767     try {
22768       result = (arg1)->AddVertexBuffer(*arg2);
22769     } catch (std::out_of_range& e) {
22770       {
22771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22772       };
22773     } catch (std::exception& e) {
22774       {
22775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22776       };
22777     } catch (...) {
22778       {
22779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22780       };
22781     }
22782   }
22783   jresult = (unsigned long)result;
22784   return jresult;
22785 }
22786
22787
22788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22789   unsigned long jresult ;
22790   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22791   std::size_t result;
22792
22793   arg1 = (Dali::Geometry *)jarg1;
22794   {
22795     try {
22796       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22797     } catch (std::out_of_range& e) {
22798       {
22799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22800       };
22801     } catch (std::exception& e) {
22802       {
22803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (...) {
22806       {
22807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22808       };
22809     }
22810   }
22811   jresult = (unsigned long)result;
22812   return jresult;
22813 }
22814
22815
22816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22817   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22818   std::size_t arg2 ;
22819
22820   arg1 = (Dali::Geometry *)jarg1;
22821   arg2 = (std::size_t)jarg2;
22822   {
22823     try {
22824       (arg1)->RemoveVertexBuffer(arg2);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22832       };
22833     } catch (...) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22836       };
22837     }
22838   }
22839 }
22840
22841
22842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22843   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22844   unsigned short *arg2 = (unsigned short *) 0 ;
22845   size_t arg3 ;
22846
22847   arg1 = (Dali::Geometry *)jarg1;
22848   arg2 = jarg2;
22849   arg3 = (size_t)jarg3;
22850   {
22851     try {
22852       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22853     } catch (std::out_of_range& e) {
22854       {
22855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22856       };
22857     } catch (std::exception& e) {
22858       {
22859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22860       };
22861     } catch (...) {
22862       {
22863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22864       };
22865     }
22866   }
22867
22868
22869 }
22870
22871
22872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22873   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22874   Dali::Geometry::Type arg2 ;
22875
22876   arg1 = (Dali::Geometry *)jarg1;
22877   arg2 = (Dali::Geometry::Type)jarg2;
22878   {
22879     try {
22880       (arg1)->SetType(arg2);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22888       };
22889     } catch (...) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22892       };
22893     }
22894   }
22895 }
22896
22897
22898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22899   int jresult ;
22900   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22901   Dali::Geometry::Type result;
22902
22903   arg1 = (Dali::Geometry *)jarg1;
22904   {
22905     try {
22906       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22907     } catch (std::out_of_range& e) {
22908       {
22909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22910       };
22911     } catch (std::exception& e) {
22912       {
22913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22914       };
22915     } catch (...) {
22916       {
22917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22918       };
22919     }
22920   }
22921   jresult = (int)result;
22922   return jresult;
22923 }
22924
22925
22926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22927   void * jresult ;
22928   Dali::Shader::Hint *result = 0 ;
22929
22930   {
22931     try {
22932       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22933     } catch (std::out_of_range& e) {
22934       {
22935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22936       };
22937     } catch (std::exception& e) {
22938       {
22939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22940       };
22941     } catch (...) {
22942       {
22943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22944       };
22945     }
22946   }
22947   jresult = (void *)result;
22948   return jresult;
22949 }
22950
22951
22952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22953   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22954
22955   arg1 = (Dali::Shader::Hint *)jarg1;
22956   {
22957     try {
22958       delete arg1;
22959     } catch (std::out_of_range& e) {
22960       {
22961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22962       };
22963     } catch (std::exception& e) {
22964       {
22965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22966       };
22967     } catch (...) {
22968       {
22969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22970       };
22971     }
22972   }
22973 }
22974
22975
22976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22977   int jresult ;
22978   int result;
22979
22980   result = (int)Dali::Shader::Property::PROGRAM;
22981   jresult = (int)result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22987   void * jresult ;
22988   Dali::Shader::Property *result = 0 ;
22989
22990   {
22991     try {
22992       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22993     } catch (std::out_of_range& e) {
22994       {
22995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22996       };
22997     } catch (std::exception& e) {
22998       {
22999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23000       };
23001     } catch (...) {
23002       {
23003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23004       };
23005     }
23006   }
23007   jresult = (void *)result;
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23013   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23014
23015   arg1 = (Dali::Shader::Property *)jarg1;
23016   {
23017     try {
23018       delete arg1;
23019     } catch (std::out_of_range& e) {
23020       {
23021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23022       };
23023     } catch (std::exception& e) {
23024       {
23025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23026       };
23027     } catch (...) {
23028       {
23029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23030       };
23031     }
23032   }
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23037   void * jresult ;
23038   std::string *arg1 = 0 ;
23039   std::string *arg2 = 0 ;
23040   Dali::Shader::Hint::Value arg3 ;
23041   Dali::Shader result;
23042
23043   if (!jarg1) {
23044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23045     return 0;
23046   }
23047   std::string arg1_str(jarg1);
23048   arg1 = &arg1_str;
23049   if (!jarg2) {
23050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23051     return 0;
23052   }
23053   std::string arg2_str(jarg2);
23054   arg2 = &arg2_str;
23055   arg3 = (Dali::Shader::Hint::Value)jarg3;
23056   {
23057     try {
23058       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23059     } catch (std::out_of_range& e) {
23060       {
23061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23062       };
23063     } catch (std::exception& e) {
23064       {
23065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23066       };
23067     } catch (...) {
23068       {
23069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23070       };
23071     }
23072   }
23073   jresult = new Dali::Shader((const Dali::Shader &)result);
23074
23075   //argout typemap for const std::string&
23076
23077
23078   //argout typemap for const std::string&
23079
23080   return jresult;
23081 }
23082
23083
23084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23085   void * jresult ;
23086   std::string *arg1 = 0 ;
23087   std::string *arg2 = 0 ;
23088   Dali::Shader result;
23089
23090   if (!jarg1) {
23091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23092     return 0;
23093   }
23094   std::string arg1_str(jarg1);
23095   arg1 = &arg1_str;
23096   if (!jarg2) {
23097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23098     return 0;
23099   }
23100   std::string arg2_str(jarg2);
23101   arg2 = &arg2_str;
23102   {
23103     try {
23104       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23105     } catch (std::out_of_range& e) {
23106       {
23107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23108       };
23109     } catch (std::exception& e) {
23110       {
23111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23112       };
23113     } catch (...) {
23114       {
23115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23116       };
23117     }
23118   }
23119   jresult = new Dali::Shader((const Dali::Shader &)result);
23120
23121   //argout typemap for const std::string&
23122
23123
23124   //argout typemap for const std::string&
23125
23126   return jresult;
23127 }
23128
23129
23130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23131   void * jresult ;
23132   Dali::Shader *result = 0 ;
23133
23134   {
23135     try {
23136       result = (Dali::Shader *)new Dali::Shader();
23137     } catch (std::out_of_range& e) {
23138       {
23139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23140       };
23141     } catch (std::exception& e) {
23142       {
23143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23144       };
23145     } catch (...) {
23146       {
23147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23148       };
23149     }
23150   }
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23157   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23158
23159   arg1 = (Dali::Shader *)jarg1;
23160   {
23161     try {
23162       delete arg1;
23163     } catch (std::out_of_range& e) {
23164       {
23165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23166       };
23167     } catch (std::exception& e) {
23168       {
23169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23170       };
23171     } catch (...) {
23172       {
23173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23174       };
23175     }
23176   }
23177 }
23178
23179
23180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23181   void * jresult ;
23182   Dali::Shader *arg1 = 0 ;
23183   Dali::Shader *result = 0 ;
23184
23185   arg1 = (Dali::Shader *)jarg1;
23186   if (!arg1) {
23187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23188     return 0;
23189   }
23190   {
23191     try {
23192       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23193     } catch (std::out_of_range& e) {
23194       {
23195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23196       };
23197     } catch (std::exception& e) {
23198       {
23199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23200       };
23201     } catch (...) {
23202       {
23203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23204       };
23205     }
23206   }
23207   jresult = (void *)result;
23208   return jresult;
23209 }
23210
23211
23212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23213   void * jresult ;
23214   Dali::BaseHandle arg1 ;
23215   Dali::BaseHandle *argp1 ;
23216   Dali::Shader result;
23217
23218   argp1 = (Dali::BaseHandle *)jarg1;
23219   if (!argp1) {
23220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23221     return 0;
23222   }
23223   arg1 = *argp1;
23224   {
23225     try {
23226       result = Dali::Shader::DownCast(arg1);
23227     } catch (std::out_of_range& e) {
23228       {
23229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23230       };
23231     } catch (std::exception& e) {
23232       {
23233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23234       };
23235     } catch (...) {
23236       {
23237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23238       };
23239     }
23240   }
23241   jresult = new Dali::Shader((const Dali::Shader &)result);
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23247   void * jresult ;
23248   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23249   Dali::Shader *arg2 = 0 ;
23250   Dali::Shader *result = 0 ;
23251
23252   arg1 = (Dali::Shader *)jarg1;
23253   arg2 = (Dali::Shader *)jarg2;
23254   if (!arg2) {
23255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23256     return 0;
23257   }
23258   {
23259     try {
23260       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23261     } catch (std::out_of_range& e) {
23262       {
23263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23264       };
23265     } catch (std::exception& e) {
23266       {
23267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23268       };
23269     } catch (...) {
23270       {
23271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23272       };
23273     }
23274   }
23275   jresult = (void *)result;
23276   return jresult;
23277 }
23278
23279
23280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23281   int jresult ;
23282   int result;
23283
23284   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23285   jresult = (int)result;
23286   return jresult;
23287 }
23288
23289
23290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23291   int jresult ;
23292   int result;
23293
23294   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23295   jresult = (int)result;
23296   return jresult;
23297 }
23298
23299
23300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23301   int jresult ;
23302   int result;
23303
23304   result = (int)Dali::Renderer::Property::BLEND_MODE;
23305   jresult = (int)result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23311   int jresult ;
23312   int result;
23313
23314   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23315   jresult = (int)result;
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23321   int jresult ;
23322   int result;
23323
23324   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23325   jresult = (int)result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23331   int jresult ;
23332   int result;
23333
23334   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23335   jresult = (int)result;
23336   return jresult;
23337 }
23338
23339
23340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23341   int jresult ;
23342   int result;
23343
23344   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23345   jresult = (int)result;
23346   return jresult;
23347 }
23348
23349
23350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23351   int jresult ;
23352   int result;
23353
23354   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23355   jresult = (int)result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23361   int jresult ;
23362   int result;
23363
23364   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23365   jresult = (int)result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23371   int jresult ;
23372   int result;
23373
23374   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23375   jresult = (int)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::RENDER_MODE;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23521   void * jresult ;
23522   Dali::Renderer::Property *result = 0 ;
23523
23524   {
23525     try {
23526       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23527     } catch (std::out_of_range& e) {
23528       {
23529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23530       };
23531     } catch (std::exception& e) {
23532       {
23533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23534       };
23535     } catch (...) {
23536       {
23537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23538       };
23539     }
23540   }
23541   jresult = (void *)result;
23542   return jresult;
23543 }
23544
23545
23546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23547   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23548
23549   arg1 = (Dali::Renderer::Property *)jarg1;
23550   {
23551     try {
23552       delete arg1;
23553     } catch (std::out_of_range& e) {
23554       {
23555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23556       };
23557     } catch (std::exception& e) {
23558       {
23559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23560       };
23561     } catch (...) {
23562       {
23563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23564       };
23565     }
23566   }
23567 }
23568
23569
23570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23571   void * jresult ;
23572   Dali::Geometry *arg1 = 0 ;
23573   Dali::Shader *arg2 = 0 ;
23574   Dali::Renderer result;
23575
23576   arg1 = (Dali::Geometry *)jarg1;
23577   if (!arg1) {
23578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23579     return 0;
23580   }
23581   arg2 = (Dali::Shader *)jarg2;
23582   if (!arg2) {
23583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23584     return 0;
23585   }
23586   {
23587     try {
23588       result = Dali::Renderer::New(*arg1,*arg2);
23589     } catch (std::out_of_range& e) {
23590       {
23591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23592       };
23593     } catch (std::exception& e) {
23594       {
23595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23596       };
23597     } catch (...) {
23598       {
23599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23600       };
23601     }
23602   }
23603   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23604   return jresult;
23605 }
23606
23607
23608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23609   void * jresult ;
23610   Dali::Renderer *result = 0 ;
23611
23612   {
23613     try {
23614       result = (Dali::Renderer *)new Dali::Renderer();
23615     } catch (std::out_of_range& e) {
23616       {
23617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23618       };
23619     } catch (std::exception& e) {
23620       {
23621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23622       };
23623     } catch (...) {
23624       {
23625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23626       };
23627     }
23628   }
23629   jresult = (void *)result;
23630   return jresult;
23631 }
23632
23633
23634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23635   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23636
23637   arg1 = (Dali::Renderer *)jarg1;
23638   {
23639     try {
23640       delete arg1;
23641     } catch (std::out_of_range& e) {
23642       {
23643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23644       };
23645     } catch (std::exception& e) {
23646       {
23647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23648       };
23649     } catch (...) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23652       };
23653     }
23654   }
23655 }
23656
23657
23658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23659   void * jresult ;
23660   Dali::Renderer *arg1 = 0 ;
23661   Dali::Renderer *result = 0 ;
23662
23663   arg1 = (Dali::Renderer *)jarg1;
23664   if (!arg1) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (...) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23682       };
23683     }
23684   }
23685   jresult = (void *)result;
23686   return jresult;
23687 }
23688
23689
23690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23691   void * jresult ;
23692   Dali::BaseHandle arg1 ;
23693   Dali::BaseHandle *argp1 ;
23694   Dali::Renderer result;
23695
23696   argp1 = (Dali::BaseHandle *)jarg1;
23697   if (!argp1) {
23698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23699     return 0;
23700   }
23701   arg1 = *argp1;
23702   {
23703     try {
23704       result = Dali::Renderer::DownCast(arg1);
23705     } catch (std::out_of_range& e) {
23706       {
23707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23708       };
23709     } catch (std::exception& e) {
23710       {
23711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23712       };
23713     } catch (...) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23716       };
23717     }
23718   }
23719   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23720   return jresult;
23721 }
23722
23723
23724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23725   void * jresult ;
23726   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23727   Dali::Renderer *arg2 = 0 ;
23728   Dali::Renderer *result = 0 ;
23729
23730   arg1 = (Dali::Renderer *)jarg1;
23731   arg2 = (Dali::Renderer *)jarg2;
23732   if (!arg2) {
23733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23734     return 0;
23735   }
23736   {
23737     try {
23738       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23739     } catch (std::out_of_range& e) {
23740       {
23741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23742       };
23743     } catch (std::exception& e) {
23744       {
23745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (...) {
23748       {
23749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23750       };
23751     }
23752   }
23753   jresult = (void *)result;
23754   return jresult;
23755 }
23756
23757
23758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23759   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23760   Dali::Geometry *arg2 = 0 ;
23761
23762   arg1 = (Dali::Renderer *)jarg1;
23763   arg2 = (Dali::Geometry *)jarg2;
23764   if (!arg2) {
23765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23766     return ;
23767   }
23768   {
23769     try {
23770       (arg1)->SetGeometry(*arg2);
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23782       };
23783     }
23784   }
23785 }
23786
23787
23788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23789   void * jresult ;
23790   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23791   Dali::Geometry result;
23792
23793   arg1 = (Dali::Renderer *)jarg1;
23794   {
23795     try {
23796       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23797     } catch (std::out_of_range& e) {
23798       {
23799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23800       };
23801     } catch (std::exception& e) {
23802       {
23803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23804       };
23805     } catch (...) {
23806       {
23807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23808       };
23809     }
23810   }
23811   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23812   return jresult;
23813 }
23814
23815
23816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23817   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23818   int arg2 ;
23819   int arg3 ;
23820
23821   arg1 = (Dali::Renderer *)jarg1;
23822   arg2 = (int)jarg2;
23823   arg3 = (int)jarg3;
23824   {
23825     try {
23826       (arg1)->SetIndexRange(arg2,arg3);
23827     } catch (std::out_of_range& e) {
23828       {
23829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23830       };
23831     } catch (std::exception& e) {
23832       {
23833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23834       };
23835     } catch (...) {
23836       {
23837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23838       };
23839     }
23840   }
23841 }
23842
23843
23844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23845   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23846   Dali::TextureSet *arg2 = 0 ;
23847
23848   arg1 = (Dali::Renderer *)jarg1;
23849   arg2 = (Dali::TextureSet *)jarg2;
23850   if (!arg2) {
23851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23852     return ;
23853   }
23854   {
23855     try {
23856       (arg1)->SetTextures(*arg2);
23857     } catch (std::out_of_range& e) {
23858       {
23859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23860       };
23861     } catch (std::exception& e) {
23862       {
23863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23864       };
23865     } catch (...) {
23866       {
23867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23868       };
23869     }
23870   }
23871 }
23872
23873
23874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23875   void * jresult ;
23876   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23877   Dali::TextureSet result;
23878
23879   arg1 = (Dali::Renderer *)jarg1;
23880   {
23881     try {
23882       result = ((Dali::Renderer const *)arg1)->GetTextures();
23883     } catch (std::out_of_range& e) {
23884       {
23885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23886       };
23887     } catch (std::exception& e) {
23888       {
23889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23890       };
23891     } catch (...) {
23892       {
23893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23894       };
23895     }
23896   }
23897   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23898   return jresult;
23899 }
23900
23901
23902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23903   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23904   Dali::Shader *arg2 = 0 ;
23905
23906   arg1 = (Dali::Renderer *)jarg1;
23907   arg2 = (Dali::Shader *)jarg2;
23908   if (!arg2) {
23909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23910     return ;
23911   }
23912   {
23913     try {
23914       (arg1)->SetShader(*arg2);
23915     } catch (std::out_of_range& e) {
23916       {
23917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23918       };
23919     } catch (std::exception& e) {
23920       {
23921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23922       };
23923     } catch (...) {
23924       {
23925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23926       };
23927     }
23928   }
23929 }
23930
23931
23932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23933   void * jresult ;
23934   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23935   Dali::Shader result;
23936
23937   arg1 = (Dali::Renderer *)jarg1;
23938   {
23939     try {
23940       result = ((Dali::Renderer const *)arg1)->GetShader();
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23952       };
23953     }
23954   }
23955   jresult = new Dali::Shader((const Dali::Shader &)result);
23956   return jresult;
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23961   void * jresult ;
23962   Dali::FrameBuffer::Attachment *result = 0 ;
23963
23964   {
23965     try {
23966       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23967     } catch (std::out_of_range& e) {
23968       {
23969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (std::exception& e) {
23972       {
23973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (...) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23978       };
23979     }
23980   }
23981   jresult = (void *)result;
23982   return jresult;
23983 }
23984
23985
23986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23987   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23988
23989   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23990   {
23991     try {
23992       delete arg1;
23993     } catch (std::out_of_range& e) {
23994       {
23995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23996       };
23997     } catch (std::exception& e) {
23998       {
23999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24000       };
24001     } catch (...) {
24002       {
24003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24004       };
24005     }
24006   }
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24011   void * jresult ;
24012   unsigned int arg1 ;
24013   unsigned int arg2 ;
24014   unsigned int arg3 ;
24015   Dali::FrameBuffer result;
24016
24017   arg1 = (unsigned int)jarg1;
24018   arg2 = (unsigned int)jarg2;
24019   arg3 = (unsigned int)jarg3;
24020   {
24021     try {
24022       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24023     } catch (std::out_of_range& e) {
24024       {
24025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24026       };
24027     } catch (std::exception& e) {
24028       {
24029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24030       };
24031     } catch (...) {
24032       {
24033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24034       };
24035     }
24036   }
24037   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24038   return jresult;
24039 }
24040
24041
24042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24043   void * jresult ;
24044   Dali::FrameBuffer *result = 0 ;
24045
24046   {
24047     try {
24048       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24049     } catch (std::out_of_range& e) {
24050       {
24051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24052       };
24053     } catch (std::exception& e) {
24054       {
24055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24056       };
24057     } catch (...) {
24058       {
24059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24060       };
24061     }
24062   }
24063   jresult = (void *)result;
24064   return jresult;
24065 }
24066
24067
24068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24069   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24070
24071   arg1 = (Dali::FrameBuffer *)jarg1;
24072   {
24073     try {
24074       delete arg1;
24075     } catch (std::out_of_range& e) {
24076       {
24077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24078       };
24079     } catch (std::exception& e) {
24080       {
24081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24082       };
24083     } catch (...) {
24084       {
24085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24086       };
24087     }
24088   }
24089 }
24090
24091
24092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24093   void * jresult ;
24094   Dali::FrameBuffer *arg1 = 0 ;
24095   Dali::FrameBuffer *result = 0 ;
24096
24097   arg1 = (Dali::FrameBuffer *)jarg1;
24098   if (!arg1) {
24099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24100     return 0;
24101   }
24102   {
24103     try {
24104       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24105     } catch (std::out_of_range& e) {
24106       {
24107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24108       };
24109     } catch (std::exception& e) {
24110       {
24111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24112       };
24113     } catch (...) {
24114       {
24115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24116       };
24117     }
24118   }
24119   jresult = (void *)result;
24120   return jresult;
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24125   void * jresult ;
24126   Dali::BaseHandle arg1 ;
24127   Dali::BaseHandle *argp1 ;
24128   Dali::FrameBuffer result;
24129
24130   argp1 = (Dali::BaseHandle *)jarg1;
24131   if (!argp1) {
24132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24133     return 0;
24134   }
24135   arg1 = *argp1;
24136   {
24137     try {
24138       result = Dali::FrameBuffer::DownCast(arg1);
24139     } catch (std::out_of_range& e) {
24140       {
24141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24142       };
24143     } catch (std::exception& e) {
24144       {
24145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24146       };
24147     } catch (...) {
24148       {
24149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24150       };
24151     }
24152   }
24153   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24159   void * jresult ;
24160   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24161   Dali::FrameBuffer *arg2 = 0 ;
24162   Dali::FrameBuffer *result = 0 ;
24163
24164   arg1 = (Dali::FrameBuffer *)jarg1;
24165   arg2 = (Dali::FrameBuffer *)jarg2;
24166   if (!arg2) {
24167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24168     return 0;
24169   }
24170   {
24171     try {
24172       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24173     } catch (std::out_of_range& e) {
24174       {
24175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24176       };
24177     } catch (std::exception& e) {
24178       {
24179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24180       };
24181     } catch (...) {
24182       {
24183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24184       };
24185     }
24186   }
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24193   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24194   Dali::Texture *arg2 = 0 ;
24195
24196   arg1 = (Dali::FrameBuffer *)jarg1;
24197   arg2 = (Dali::Texture *)jarg2;
24198   if (!arg2) {
24199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24200     return ;
24201   }
24202   {
24203     try {
24204       (arg1)->AttachColorTexture(*arg2);
24205     } catch (std::out_of_range& e) {
24206       {
24207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24208       };
24209     } catch (std::exception& e) {
24210       {
24211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24212       };
24213     } catch (...) {
24214       {
24215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24216       };
24217     }
24218   }
24219 }
24220
24221
24222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24223   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24224   Dali::Texture *arg2 = 0 ;
24225   unsigned int arg3 ;
24226   unsigned int arg4 ;
24227
24228   arg1 = (Dali::FrameBuffer *)jarg1;
24229   arg2 = (Dali::Texture *)jarg2;
24230   if (!arg2) {
24231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24232     return ;
24233   }
24234   arg3 = (unsigned int)jarg3;
24235   arg4 = (unsigned int)jarg4;
24236   {
24237     try {
24238       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24250       };
24251     }
24252   }
24253 }
24254
24255
24256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24257   void * jresult ;
24258   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24259   Dali::Texture result;
24260
24261   arg1 = (Dali::FrameBuffer *)jarg1;
24262   {
24263     try {
24264       result = (arg1)->GetColorTexture();
24265     } catch (std::out_of_range& e) {
24266       {
24267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24268       };
24269     } catch (std::exception& e) {
24270       {
24271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24272       };
24273     } catch (...) {
24274       {
24275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24276       };
24277     }
24278   }
24279   jresult = new Dali::Texture((const Dali::Texture &)result);
24280   return jresult;
24281 }
24282
24283
24284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24285   void * jresult ;
24286   Dali::RenderTaskList *result = 0 ;
24287
24288   {
24289     try {
24290       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24291     } catch (std::out_of_range& e) {
24292       {
24293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24294       };
24295     } catch (std::exception& e) {
24296       {
24297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24298       };
24299     } catch (...) {
24300       {
24301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24302       };
24303     }
24304   }
24305   jresult = (void *)result;
24306   return jresult;
24307 }
24308
24309
24310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24311   void * jresult ;
24312   Dali::BaseHandle arg1 ;
24313   Dali::BaseHandle *argp1 ;
24314   Dali::RenderTaskList result;
24315
24316   argp1 = (Dali::BaseHandle *)jarg1;
24317   if (!argp1) {
24318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24319     return 0;
24320   }
24321   arg1 = *argp1;
24322   {
24323     try {
24324       result = Dali::RenderTaskList::DownCast(arg1);
24325     } catch (std::out_of_range& e) {
24326       {
24327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24328       };
24329     } catch (std::exception& e) {
24330       {
24331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24332       };
24333     } catch (...) {
24334       {
24335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24336       };
24337     }
24338   }
24339   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24345   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24346
24347   arg1 = (Dali::RenderTaskList *)jarg1;
24348   {
24349     try {
24350       delete arg1;
24351     } catch (std::out_of_range& e) {
24352       {
24353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24354       };
24355     } catch (std::exception& e) {
24356       {
24357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24358       };
24359     } catch (...) {
24360       {
24361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24362       };
24363     }
24364   }
24365 }
24366
24367
24368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24369   void * jresult ;
24370   Dali::RenderTaskList *arg1 = 0 ;
24371   Dali::RenderTaskList *result = 0 ;
24372
24373   arg1 = (Dali::RenderTaskList *)jarg1;
24374   if (!arg1) {
24375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24376     return 0;
24377   }
24378   {
24379     try {
24380       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24381     } catch (std::out_of_range& e) {
24382       {
24383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24384       };
24385     } catch (std::exception& e) {
24386       {
24387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (...) {
24390       {
24391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24392       };
24393     }
24394   }
24395   jresult = (void *)result;
24396   return jresult;
24397 }
24398
24399
24400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24401   void * jresult ;
24402   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24403   Dali::RenderTaskList *arg2 = 0 ;
24404   Dali::RenderTaskList *result = 0 ;
24405
24406   arg1 = (Dali::RenderTaskList *)jarg1;
24407   arg2 = (Dali::RenderTaskList *)jarg2;
24408   if (!arg2) {
24409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24410     return 0;
24411   }
24412   {
24413     try {
24414       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24415     } catch (std::out_of_range& e) {
24416       {
24417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24418       };
24419     } catch (std::exception& e) {
24420       {
24421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24422       };
24423     } catch (...) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24426       };
24427     }
24428   }
24429   jresult = (void *)result;
24430   return jresult;
24431 }
24432
24433
24434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24435   void * jresult ;
24436   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24437   Dali::RenderTask result;
24438
24439   arg1 = (Dali::RenderTaskList *)jarg1;
24440   {
24441     try {
24442       result = (arg1)->CreateTask();
24443     } catch (std::out_of_range& e) {
24444       {
24445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24446       };
24447     } catch (std::exception& e) {
24448       {
24449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24450       };
24451     } catch (...) {
24452       {
24453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24454       };
24455     }
24456   }
24457   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24458   return jresult;
24459 }
24460
24461
24462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24463   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24464   Dali::RenderTask arg2 ;
24465   Dali::RenderTask *argp2 ;
24466
24467   arg1 = (Dali::RenderTaskList *)jarg1;
24468   argp2 = (Dali::RenderTask *)jarg2;
24469   if (!argp2) {
24470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24471     return ;
24472   }
24473   arg2 = *argp2;
24474   {
24475     try {
24476       (arg1)->RemoveTask(arg2);
24477     } catch (std::out_of_range& e) {
24478       {
24479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24480       };
24481     } catch (std::exception& e) {
24482       {
24483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24484       };
24485     } catch (...) {
24486       {
24487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24488       };
24489     }
24490   }
24491 }
24492
24493
24494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24495   unsigned int jresult ;
24496   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24497   unsigned int result;
24498
24499   arg1 = (Dali::RenderTaskList *)jarg1;
24500   {
24501     try {
24502       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24503     } catch (std::out_of_range& e) {
24504       {
24505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24506       };
24507     } catch (std::exception& e) {
24508       {
24509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24510       };
24511     } catch (...) {
24512       {
24513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24514       };
24515     }
24516   }
24517   jresult = result;
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24523   void * jresult ;
24524   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24525   unsigned int arg2 ;
24526   Dali::RenderTask result;
24527
24528   arg1 = (Dali::RenderTaskList *)jarg1;
24529   arg2 = (unsigned int)jarg2;
24530   {
24531     try {
24532       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24533     } catch (std::out_of_range& e) {
24534       {
24535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (std::exception& e) {
24538       {
24539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24553   int jresult ;
24554   int result;
24555
24556   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24557   jresult = (int)result;
24558   return jresult;
24559 }
24560
24561
24562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24563   int jresult ;
24564   int result;
24565
24566   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24567   jresult = (int)result;
24568   return jresult;
24569 }
24570
24571
24572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24573   int jresult ;
24574   int result;
24575
24576   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24577   jresult = (int)result;
24578   return jresult;
24579 }
24580
24581
24582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24583   int jresult ;
24584   int result;
24585
24586   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24587   jresult = (int)result;
24588   return jresult;
24589 }
24590
24591
24592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24593   void * jresult ;
24594   Dali::RenderTask::Property *result = 0 ;
24595
24596   {
24597     try {
24598       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24599     } catch (std::out_of_range& e) {
24600       {
24601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (std::exception& e) {
24604       {
24605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (...) {
24608       {
24609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24610       };
24611     }
24612   }
24613   jresult = (void *)result;
24614   return jresult;
24615 }
24616
24617
24618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24619   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24620
24621   arg1 = (Dali::RenderTask::Property *)jarg1;
24622   {
24623     try {
24624       delete arg1;
24625     } catch (std::out_of_range& e) {
24626       {
24627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24628       };
24629     } catch (std::exception& e) {
24630       {
24631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24632       };
24633     } catch (...) {
24634       {
24635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24636       };
24637     }
24638   }
24639 }
24640
24641
24642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24643   void * jresult ;
24644   bool (*result)(Dali::Vector2 &) = 0 ;
24645
24646   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24647   jresult = (void *)result;
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24653   void * jresult ;
24654   bool (*result)(Dali::Vector2 &) = 0 ;
24655
24656   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24657   jresult = (void *)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24663   unsigned int jresult ;
24664   bool result;
24665
24666   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24667   jresult = result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24673   unsigned int jresult ;
24674   bool result;
24675
24676   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24677   jresult = result;
24678   return jresult;
24679 }
24680
24681
24682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24683   void * jresult ;
24684   Dali::Vector4 *result = 0 ;
24685
24686   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24687   jresult = (void *)result;
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24693   unsigned int jresult ;
24694   bool result;
24695
24696   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24697   jresult = result;
24698   return jresult;
24699 }
24700
24701
24702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24703   unsigned int jresult ;
24704   bool result;
24705
24706   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24713   unsigned int jresult ;
24714   unsigned int result;
24715
24716   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24717   jresult = result;
24718   return jresult;
24719 }
24720
24721
24722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24723   void * jresult ;
24724   Dali::RenderTask *result = 0 ;
24725
24726   {
24727     try {
24728       result = (Dali::RenderTask *)new Dali::RenderTask();
24729     } catch (std::out_of_range& e) {
24730       {
24731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24732       };
24733     } catch (std::exception& e) {
24734       {
24735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24736       };
24737     } catch (...) {
24738       {
24739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24740       };
24741     }
24742   }
24743   jresult = (void *)result;
24744   return jresult;
24745 }
24746
24747
24748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24749   void * jresult ;
24750   Dali::BaseHandle arg1 ;
24751   Dali::BaseHandle *argp1 ;
24752   Dali::RenderTask result;
24753
24754   argp1 = (Dali::BaseHandle *)jarg1;
24755   if (!argp1) {
24756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24757     return 0;
24758   }
24759   arg1 = *argp1;
24760   {
24761     try {
24762       result = Dali::RenderTask::DownCast(arg1);
24763     } catch (std::out_of_range& e) {
24764       {
24765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24766       };
24767     } catch (std::exception& e) {
24768       {
24769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24770       };
24771     } catch (...) {
24772       {
24773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24774       };
24775     }
24776   }
24777   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24783   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24784
24785   arg1 = (Dali::RenderTask *)jarg1;
24786   {
24787     try {
24788       delete arg1;
24789     } catch (std::out_of_range& e) {
24790       {
24791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24792       };
24793     } catch (std::exception& e) {
24794       {
24795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24796       };
24797     } catch (...) {
24798       {
24799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24800       };
24801     }
24802   }
24803 }
24804
24805
24806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24807   void * jresult ;
24808   Dali::RenderTask *arg1 = 0 ;
24809   Dali::RenderTask *result = 0 ;
24810
24811   arg1 = (Dali::RenderTask *)jarg1;
24812   if (!arg1) {
24813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24814     return 0;
24815   }
24816   {
24817     try {
24818       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24819     } catch (std::out_of_range& e) {
24820       {
24821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24822       };
24823     } catch (std::exception& e) {
24824       {
24825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24826       };
24827     } catch (...) {
24828       {
24829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24830       };
24831     }
24832   }
24833   jresult = (void *)result;
24834   return jresult;
24835 }
24836
24837
24838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24839   void * jresult ;
24840   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24841   Dali::RenderTask *arg2 = 0 ;
24842   Dali::RenderTask *result = 0 ;
24843
24844   arg1 = (Dali::RenderTask *)jarg1;
24845   arg2 = (Dali::RenderTask *)jarg2;
24846   if (!arg2) {
24847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24848     return 0;
24849   }
24850   {
24851     try {
24852       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24853     } catch (std::out_of_range& e) {
24854       {
24855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (std::exception& e) {
24858       {
24859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867   jresult = (void *)result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24873   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24874   Dali::Actor arg2 ;
24875   Dali::Actor *argp2 ;
24876
24877   arg1 = (Dali::RenderTask *)jarg1;
24878   argp2 = (Dali::Actor *)jarg2;
24879   if (!argp2) {
24880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24881     return ;
24882   }
24883   arg2 = *argp2;
24884   {
24885     try {
24886       (arg1)->SetSourceActor(arg2);
24887     } catch (std::out_of_range& e) {
24888       {
24889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (std::exception& e) {
24892       {
24893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24898       };
24899     }
24900   }
24901 }
24902
24903
24904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24905   void * jresult ;
24906   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24907   Dali::Actor result;
24908
24909   arg1 = (Dali::RenderTask *)jarg1;
24910   {
24911     try {
24912       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24913     } catch (std::out_of_range& e) {
24914       {
24915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24916       };
24917     } catch (std::exception& e) {
24918       {
24919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24920       };
24921     } catch (...) {
24922       {
24923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24924       };
24925     }
24926   }
24927   jresult = new Dali::Actor((const Dali::Actor &)result);
24928   return jresult;
24929 }
24930
24931
24932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24934   bool arg2 ;
24935
24936   arg1 = (Dali::RenderTask *)jarg1;
24937   arg2 = jarg2 ? true : false;
24938   {
24939     try {
24940       (arg1)->SetExclusive(arg2);
24941     } catch (std::out_of_range& e) {
24942       {
24943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24944       };
24945     } catch (std::exception& e) {
24946       {
24947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24948       };
24949     } catch (...) {
24950       {
24951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24952       };
24953     }
24954   }
24955 }
24956
24957
24958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24959   unsigned int jresult ;
24960   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24961   bool result;
24962
24963   arg1 = (Dali::RenderTask *)jarg1;
24964   {
24965     try {
24966       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24967     } catch (std::out_of_range& e) {
24968       {
24969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24970       };
24971     } catch (std::exception& e) {
24972       {
24973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24974       };
24975     } catch (...) {
24976       {
24977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24978       };
24979     }
24980   }
24981   jresult = result;
24982   return jresult;
24983 }
24984
24985
24986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24987   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24988   bool arg2 ;
24989
24990   arg1 = (Dali::RenderTask *)jarg1;
24991   arg2 = jarg2 ? true : false;
24992   {
24993     try {
24994       (arg1)->SetInputEnabled(arg2);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (...) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25006       };
25007     }
25008   }
25009 }
25010
25011
25012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25013   unsigned int jresult ;
25014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25015   bool result;
25016
25017   arg1 = (Dali::RenderTask *)jarg1;
25018   {
25019     try {
25020       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25032       };
25033     }
25034   }
25035   jresult = result;
25036   return jresult;
25037 }
25038
25039
25040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25042   Dali::CameraActor arg2 ;
25043   Dali::CameraActor *argp2 ;
25044
25045   arg1 = (Dali::RenderTask *)jarg1;
25046   argp2 = (Dali::CameraActor *)jarg2;
25047   if (!argp2) {
25048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25049     return ;
25050   }
25051   arg2 = *argp2;
25052   {
25053     try {
25054       (arg1)->SetCameraActor(arg2);
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25066       };
25067     }
25068   }
25069 }
25070
25071
25072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25073   void * jresult ;
25074   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25075   Dali::CameraActor result;
25076
25077   arg1 = (Dali::RenderTask *)jarg1;
25078   {
25079     try {
25080       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25081     } catch (std::out_of_range& e) {
25082       {
25083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25084       };
25085     } catch (std::exception& e) {
25086       {
25087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (...) {
25090       {
25091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25092       };
25093     }
25094   }
25095   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25096   return jresult;
25097 }
25098
25099
25100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25101   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25102   Dali::FrameBufferImage arg2 ;
25103   Dali::FrameBufferImage *argp2 ;
25104
25105   arg1 = (Dali::RenderTask *)jarg1;
25106   argp2 = (Dali::FrameBufferImage *)jarg2;
25107   if (!argp2) {
25108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25109     return ;
25110   }
25111   arg2 = *argp2;
25112   {
25113     try {
25114       (arg1)->SetTargetFrameBuffer(arg2);
25115     } catch (std::out_of_range& e) {
25116       {
25117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25118       };
25119     } catch (std::exception& e) {
25120       {
25121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25122       };
25123     } catch (...) {
25124       {
25125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25126       };
25127     }
25128   }
25129 }
25130
25131
25132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25133   void * jresult ;
25134   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25135   Dali::FrameBufferImage result;
25136
25137   arg1 = (Dali::RenderTask *)jarg1;
25138   {
25139     try {
25140       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25141     } catch (std::out_of_range& e) {
25142       {
25143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25144       };
25145     } catch (std::exception& e) {
25146       {
25147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25148       };
25149     } catch (...) {
25150       {
25151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25152       };
25153     }
25154   }
25155   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25156   return jresult;
25157 }
25158
25159
25160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25161   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25162   Dali::FrameBuffer arg2 ;
25163   Dali::FrameBuffer *argp2 ;
25164
25165   arg1 = (Dali::RenderTask *)jarg1;
25166   argp2 = (Dali::FrameBuffer *)jarg2;
25167   if (!argp2) {
25168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25169     return ;
25170   }
25171   arg2 = *argp2;
25172   {
25173     try {
25174       (arg1)->SetFrameBuffer(arg2);
25175     } catch (std::out_of_range& e) {
25176       {
25177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25178       };
25179     } catch (std::exception& e) {
25180       {
25181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25182       };
25183     } catch (...) {
25184       {
25185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25186       };
25187     }
25188   }
25189 }
25190
25191
25192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25193   void * jresult ;
25194   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25195   Dali::FrameBuffer result;
25196
25197   arg1 = (Dali::RenderTask *)jarg1;
25198   {
25199     try {
25200       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25201     } catch (std::out_of_range& e) {
25202       {
25203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25204       };
25205     } catch (std::exception& e) {
25206       {
25207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25208       };
25209     } catch (...) {
25210       {
25211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25212       };
25213     }
25214   }
25215   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25216   return jresult;
25217 }
25218
25219
25220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25222   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25223
25224   arg1 = (Dali::RenderTask *)jarg1;
25225   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25226   {
25227     try {
25228       (arg1)->SetScreenToFrameBufferFunction(arg2);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25236       };
25237     } catch (...) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25240       };
25241     }
25242   }
25243 }
25244
25245
25246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25247   void * jresult ;
25248   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25249   Dali::RenderTask::ScreenToFrameBufferFunction result;
25250
25251   arg1 = (Dali::RenderTask *)jarg1;
25252   {
25253     try {
25254       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25255     } catch (std::out_of_range& e) {
25256       {
25257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25258       };
25259     } catch (std::exception& e) {
25260       {
25261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25266       };
25267     }
25268   }
25269   jresult = (void *)result;
25270   return jresult;
25271 }
25272
25273
25274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25276   Dali::Actor arg2 ;
25277   Dali::Actor *argp2 ;
25278
25279   arg1 = (Dali::RenderTask *)jarg1;
25280   argp2 = (Dali::Actor *)jarg2;
25281   if (!argp2) {
25282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25283     return ;
25284   }
25285   arg2 = *argp2;
25286   {
25287     try {
25288       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25289     } catch (std::out_of_range& e) {
25290       {
25291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25292       };
25293     } catch (std::exception& e) {
25294       {
25295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25296       };
25297     } catch (...) {
25298       {
25299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25300       };
25301     }
25302   }
25303 }
25304
25305
25306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25307   void * jresult ;
25308   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25309   Dali::Actor result;
25310
25311   arg1 = (Dali::RenderTask *)jarg1;
25312   {
25313     try {
25314       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25315     } catch (std::out_of_range& e) {
25316       {
25317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25318       };
25319     } catch (std::exception& e) {
25320       {
25321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25322       };
25323     } catch (...) {
25324       {
25325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25326       };
25327     }
25328   }
25329   jresult = new Dali::Actor((const Dali::Actor &)result);
25330   return jresult;
25331 }
25332
25333
25334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25335   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25336   Dali::Vector2 arg2 ;
25337   Dali::Vector2 *argp2 ;
25338
25339   arg1 = (Dali::RenderTask *)jarg1;
25340   argp2 = (Dali::Vector2 *)jarg2;
25341   if (!argp2) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25343     return ;
25344   }
25345   arg2 = *argp2;
25346   {
25347     try {
25348       (arg1)->SetViewportPosition(arg2);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363 }
25364
25365
25366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25367   void * jresult ;
25368   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25369   Dali::Vector2 result;
25370
25371   arg1 = (Dali::RenderTask *)jarg1;
25372   {
25373     try {
25374       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25375     } catch (std::out_of_range& e) {
25376       {
25377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (std::exception& e) {
25380       {
25381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (...) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25386       };
25387     }
25388   }
25389   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25390   return jresult;
25391 }
25392
25393
25394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25395   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25396   Dali::Vector2 arg2 ;
25397   Dali::Vector2 *argp2 ;
25398
25399   arg1 = (Dali::RenderTask *)jarg1;
25400   argp2 = (Dali::Vector2 *)jarg2;
25401   if (!argp2) {
25402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25403     return ;
25404   }
25405   arg2 = *argp2;
25406   {
25407     try {
25408       (arg1)->SetViewportSize(arg2);
25409     } catch (std::out_of_range& e) {
25410       {
25411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25412       };
25413     } catch (std::exception& e) {
25414       {
25415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25420       };
25421     }
25422   }
25423 }
25424
25425
25426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25427   void * jresult ;
25428   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25429   Dali::Vector2 result;
25430
25431   arg1 = (Dali::RenderTask *)jarg1;
25432   {
25433     try {
25434       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25435     } catch (std::out_of_range& e) {
25436       {
25437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25438       };
25439     } catch (std::exception& e) {
25440       {
25441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25442       };
25443     } catch (...) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25446       };
25447     }
25448   }
25449   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25450   return jresult;
25451 }
25452
25453
25454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25455   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25456   Dali::Viewport arg2 ;
25457   Dali::Viewport *argp2 ;
25458
25459   arg1 = (Dali::RenderTask *)jarg1;
25460   argp2 = (Dali::Viewport *)jarg2;
25461   if (!argp2) {
25462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25463     return ;
25464   }
25465   arg2 = *argp2;
25466   {
25467     try {
25468       (arg1)->SetViewport(arg2);
25469     } catch (std::out_of_range& e) {
25470       {
25471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25472       };
25473     } catch (std::exception& e) {
25474       {
25475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25476       };
25477     } catch (...) {
25478       {
25479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25480       };
25481     }
25482   }
25483 }
25484
25485
25486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25487   void * jresult ;
25488   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25489   Dali::Viewport result;
25490
25491   arg1 = (Dali::RenderTask *)jarg1;
25492   {
25493     try {
25494       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25495     } catch (std::out_of_range& e) {
25496       {
25497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25498       };
25499     } catch (std::exception& e) {
25500       {
25501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (...) {
25504       {
25505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25506       };
25507     }
25508   }
25509   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25510   return jresult;
25511 }
25512
25513
25514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25515   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25516   Dali::Vector4 *arg2 = 0 ;
25517
25518   arg1 = (Dali::RenderTask *)jarg1;
25519   arg2 = (Dali::Vector4 *)jarg2;
25520   if (!arg2) {
25521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25522     return ;
25523   }
25524   {
25525     try {
25526       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25527     } catch (std::out_of_range& e) {
25528       {
25529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25530       };
25531     } catch (std::exception& e) {
25532       {
25533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25534       };
25535     } catch (...) {
25536       {
25537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25538       };
25539     }
25540   }
25541 }
25542
25543
25544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25545   void * jresult ;
25546   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25547   Dali::Vector4 result;
25548
25549   arg1 = (Dali::RenderTask *)jarg1;
25550   {
25551     try {
25552       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25553     } catch (std::out_of_range& e) {
25554       {
25555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (std::exception& e) {
25558       {
25559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25568   return jresult;
25569 }
25570
25571
25572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25574   bool arg2 ;
25575
25576   arg1 = (Dali::RenderTask *)jarg1;
25577   arg2 = jarg2 ? true : false;
25578   {
25579     try {
25580       (arg1)->SetClearEnabled(arg2);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25588       };
25589     } catch (...) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25592       };
25593     }
25594   }
25595 }
25596
25597
25598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25599   unsigned int jresult ;
25600   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25601   bool result;
25602
25603   arg1 = (Dali::RenderTask *)jarg1;
25604   {
25605     try {
25606       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25607     } catch (std::out_of_range& e) {
25608       {
25609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25610       };
25611     } catch (std::exception& e) {
25612       {
25613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25614       };
25615     } catch (...) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25618       };
25619     }
25620   }
25621   jresult = result;
25622   return jresult;
25623 }
25624
25625
25626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25628   bool arg2 ;
25629
25630   arg1 = (Dali::RenderTask *)jarg1;
25631   arg2 = jarg2 ? true : false;
25632   {
25633     try {
25634       (arg1)->SetCullMode(arg2);
25635     } catch (std::out_of_range& e) {
25636       {
25637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25638       };
25639     } catch (std::exception& e) {
25640       {
25641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25642       };
25643     } catch (...) {
25644       {
25645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25646       };
25647     }
25648   }
25649 }
25650
25651
25652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25653   unsigned int jresult ;
25654   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25655   bool result;
25656
25657   arg1 = (Dali::RenderTask *)jarg1;
25658   {
25659     try {
25660       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25661     } catch (std::out_of_range& e) {
25662       {
25663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25664       };
25665     } catch (std::exception& e) {
25666       {
25667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25672       };
25673     }
25674   }
25675   jresult = result;
25676   return jresult;
25677 }
25678
25679
25680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25681   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25682   unsigned int arg2 ;
25683
25684   arg1 = (Dali::RenderTask *)jarg1;
25685   arg2 = (unsigned int)jarg2;
25686   {
25687     try {
25688       (arg1)->SetRefreshRate(arg2);
25689     } catch (std::out_of_range& e) {
25690       {
25691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25692       };
25693     } catch (std::exception& e) {
25694       {
25695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25696       };
25697     } catch (...) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25700       };
25701     }
25702   }
25703 }
25704
25705
25706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25707   unsigned int jresult ;
25708   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25709   unsigned int result;
25710
25711   arg1 = (Dali::RenderTask *)jarg1;
25712   {
25713     try {
25714       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (...) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25726       };
25727     }
25728   }
25729   jresult = result;
25730   return jresult;
25731 }
25732
25733
25734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25735   unsigned int jresult ;
25736   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25737   Dali::Vector3 *arg2 = 0 ;
25738   float *arg3 = 0 ;
25739   float *arg4 = 0 ;
25740   bool result;
25741
25742   arg1 = (Dali::RenderTask *)jarg1;
25743   arg2 = (Dali::Vector3 *)jarg2;
25744   if (!arg2) {
25745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25746     return 0;
25747   }
25748   arg3 = (float *)jarg3;
25749   arg4 = (float *)jarg4;
25750   {
25751     try {
25752       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25753     } catch (std::out_of_range& e) {
25754       {
25755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (std::exception& e) {
25758       {
25759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25764       };
25765     }
25766   }
25767   jresult = result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25773   unsigned int jresult ;
25774   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25775   Dali::Actor arg2 ;
25776   float arg3 ;
25777   float arg4 ;
25778   float *arg5 = 0 ;
25779   float *arg6 = 0 ;
25780   Dali::Actor *argp2 ;
25781   bool result;
25782
25783   arg1 = (Dali::RenderTask *)jarg1;
25784   argp2 = (Dali::Actor *)jarg2;
25785   if (!argp2) {
25786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25787     return 0;
25788   }
25789   arg2 = *argp2;
25790   arg3 = (float)jarg3;
25791   arg4 = (float)jarg4;
25792   arg5 = (float *)jarg5;
25793   arg6 = (float *)jarg6;
25794   {
25795     try {
25796       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25797     } catch (std::out_of_range& e) {
25798       {
25799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25800       };
25801     } catch (std::exception& e) {
25802       {
25803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25804       };
25805     } catch (...) {
25806       {
25807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25808       };
25809     }
25810   }
25811   jresult = result;
25812   return jresult;
25813 }
25814
25815
25816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25817   void * jresult ;
25818   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25819   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25820
25821   arg1 = (Dali::RenderTask *)jarg1;
25822   {
25823     try {
25824       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25825     } catch (std::out_of_range& e) {
25826       {
25827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (std::exception& e) {
25830       {
25831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839   jresult = (void *)result;
25840   return jresult;
25841 }
25842
25843
25844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25845   void * jresult ;
25846   int arg1 ;
25847   Dali::TouchPoint::State arg2 ;
25848   float arg3 ;
25849   float arg4 ;
25850   Dali::TouchPoint *result = 0 ;
25851
25852   arg1 = (int)jarg1;
25853   arg2 = (Dali::TouchPoint::State)jarg2;
25854   arg3 = (float)jarg3;
25855   arg4 = (float)jarg4;
25856   {
25857     try {
25858       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25859     } catch (std::out_of_range& e) {
25860       {
25861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (std::exception& e) {
25864       {
25865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25866       };
25867     } catch (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25870       };
25871     }
25872   }
25873   jresult = (void *)result;
25874   return jresult;
25875 }
25876
25877
25878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25879   void * jresult ;
25880   int arg1 ;
25881   Dali::TouchPoint::State arg2 ;
25882   float arg3 ;
25883   float arg4 ;
25884   float arg5 ;
25885   float arg6 ;
25886   Dali::TouchPoint *result = 0 ;
25887
25888   arg1 = (int)jarg1;
25889   arg2 = (Dali::TouchPoint::State)jarg2;
25890   arg3 = (float)jarg3;
25891   arg4 = (float)jarg4;
25892   arg5 = (float)jarg5;
25893   arg6 = (float)jarg6;
25894   {
25895     try {
25896       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25917   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25918
25919   arg1 = (Dali::TouchPoint *)jarg1;
25920   {
25921     try {
25922       delete arg1;
25923     } catch (std::out_of_range& e) {
25924       {
25925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25926       };
25927     } catch (std::exception& e) {
25928       {
25929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25930       };
25931     } catch (...) {
25932       {
25933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25934       };
25935     }
25936   }
25937 }
25938
25939
25940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25941   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25942   int arg2 ;
25943
25944   arg1 = (Dali::TouchPoint *)jarg1;
25945   arg2 = (int)jarg2;
25946   if (arg1) (arg1)->deviceId = arg2;
25947 }
25948
25949
25950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25951   int jresult ;
25952   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25953   int result;
25954
25955   arg1 = (Dali::TouchPoint *)jarg1;
25956   result = (int) ((arg1)->deviceId);
25957   jresult = result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25963   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25964   Dali::TouchPoint::State arg2 ;
25965
25966   arg1 = (Dali::TouchPoint *)jarg1;
25967   arg2 = (Dali::TouchPoint::State)jarg2;
25968   if (arg1) (arg1)->state = arg2;
25969 }
25970
25971
25972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25973   int jresult ;
25974   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25975   Dali::TouchPoint::State result;
25976
25977   arg1 = (Dali::TouchPoint *)jarg1;
25978   result = (Dali::TouchPoint::State) ((arg1)->state);
25979   jresult = (int)result;
25980   return jresult;
25981 }
25982
25983
25984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25985   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25986   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25987
25988   arg1 = (Dali::TouchPoint *)jarg1;
25989   arg2 = (Dali::Actor *)jarg2;
25990   if (arg1) (arg1)->hitActor = *arg2;
25991 }
25992
25993
25994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25995   void * jresult ;
25996   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25997   Dali::Actor *result = 0 ;
25998
25999   arg1 = (Dali::TouchPoint *)jarg1;
26000   result = (Dali::Actor *)& ((arg1)->hitActor);
26001   jresult = (void *)result;
26002   return jresult;
26003 }
26004
26005
26006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26007   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26008   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26009
26010   arg1 = (Dali::TouchPoint *)jarg1;
26011   arg2 = (Dali::Vector2 *)jarg2;
26012   if (arg1) (arg1)->local = *arg2;
26013 }
26014
26015
26016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26017   void * jresult ;
26018   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26019   Dali::Vector2 *result = 0 ;
26020
26021   arg1 = (Dali::TouchPoint *)jarg1;
26022   result = (Dali::Vector2 *)& ((arg1)->local);
26023   jresult = (void *)result;
26024   return jresult;
26025 }
26026
26027
26028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26029   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26030   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26031
26032   arg1 = (Dali::TouchPoint *)jarg1;
26033   arg2 = (Dali::Vector2 *)jarg2;
26034   if (arg1) (arg1)->screen = *arg2;
26035 }
26036
26037
26038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26039   void * jresult ;
26040   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26041   Dali::Vector2 *result = 0 ;
26042
26043   arg1 = (Dali::TouchPoint *)jarg1;
26044   result = (Dali::Vector2 *)& ((arg1)->screen);
26045   jresult = (void *)result;
26046   return jresult;
26047 }
26048
26049
26050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26051   void * jresult ;
26052   Dali::TouchData *result = 0 ;
26053
26054   {
26055     try {
26056       result = (Dali::TouchData *)new Dali::TouchData();
26057     } catch (std::out_of_range& e) {
26058       {
26059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26060       };
26061     } catch (std::exception& e) {
26062       {
26063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26064       };
26065     } catch (...) {
26066       {
26067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26068       };
26069     }
26070   }
26071   jresult = (void *)result;
26072   return jresult;
26073 }
26074
26075
26076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26077   void * jresult ;
26078   Dali::TouchData *arg1 = 0 ;
26079   Dali::TouchData *result = 0 ;
26080
26081   arg1 = (Dali::TouchData *)jarg1;
26082   if (!arg1) {
26083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26084     return 0;
26085   }
26086   {
26087     try {
26088       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26089     } catch (std::out_of_range& e) {
26090       {
26091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26092       };
26093     } catch (std::exception& e) {
26094       {
26095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26096       };
26097     } catch (...) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26100       };
26101     }
26102   }
26103   jresult = (void *)result;
26104   return jresult;
26105 }
26106
26107
26108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26109   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26110
26111   arg1 = (Dali::TouchData *)jarg1;
26112   {
26113     try {
26114       delete arg1;
26115     } catch (std::out_of_range& e) {
26116       {
26117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26118       };
26119     } catch (std::exception& e) {
26120       {
26121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26122       };
26123     } catch (...) {
26124       {
26125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26126       };
26127     }
26128   }
26129 }
26130
26131
26132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26133   void * jresult ;
26134   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26135   Dali::TouchData *arg2 = 0 ;
26136   Dali::TouchData *result = 0 ;
26137
26138   arg1 = (Dali::TouchData *)jarg1;
26139   arg2 = (Dali::TouchData *)jarg2;
26140   if (!arg2) {
26141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26142     return 0;
26143   }
26144   {
26145     try {
26146       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26147     } catch (std::out_of_range& e) {
26148       {
26149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26150       };
26151     } catch (std::exception& e) {
26152       {
26153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26154       };
26155     } catch (...) {
26156       {
26157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26158       };
26159     }
26160   }
26161   jresult = (void *)result;
26162   return jresult;
26163 }
26164
26165
26166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26167   unsigned long jresult ;
26168   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26169   unsigned long result;
26170
26171   arg1 = (Dali::TouchData *)jarg1;
26172   {
26173     try {
26174       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26175     } catch (std::out_of_range& e) {
26176       {
26177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26178       };
26179     } catch (std::exception& e) {
26180       {
26181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26182       };
26183     } catch (...) {
26184       {
26185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26186       };
26187     }
26188   }
26189   jresult = (unsigned long)result;
26190   return jresult;
26191 }
26192
26193
26194 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26195   unsigned long jresult ;
26196   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26197   std::size_t result;
26198
26199   arg1 = (Dali::TouchData *)jarg1;
26200   {
26201     try {
26202       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26203     } catch (std::out_of_range& e) {
26204       {
26205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (std::exception& e) {
26208       {
26209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217   jresult = (unsigned long)result;
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26223   int jresult ;
26224   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26225   std::size_t arg2 ;
26226   int32_t result;
26227
26228   arg1 = (Dali::TouchData *)jarg1;
26229   arg2 = (std::size_t)jarg2;
26230   {
26231     try {
26232       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26240       };
26241     } catch (...) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26244       };
26245     }
26246   }
26247   jresult = result;
26248   return jresult;
26249 }
26250
26251
26252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26253   int jresult ;
26254   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26255   std::size_t arg2 ;
26256   Dali::PointState::Type result;
26257
26258   arg1 = (Dali::TouchData *)jarg1;
26259   arg2 = (std::size_t)jarg2;
26260   {
26261     try {
26262       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26263     } catch (std::out_of_range& e) {
26264       {
26265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26266       };
26267     } catch (std::exception& e) {
26268       {
26269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26270       };
26271     } catch (...) {
26272       {
26273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26274       };
26275     }
26276   }
26277   jresult = (int)result;
26278   return jresult;
26279 }
26280
26281
26282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26283   void * jresult ;
26284   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26285   std::size_t arg2 ;
26286   Dali::Actor result;
26287
26288   arg1 = (Dali::TouchData *)jarg1;
26289   arg2 = (std::size_t)jarg2;
26290   {
26291     try {
26292       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26293     } catch (std::out_of_range& e) {
26294       {
26295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26296       };
26297     } catch (std::exception& e) {
26298       {
26299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26300       };
26301     } catch (...) {
26302       {
26303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26304       };
26305     }
26306   }
26307   jresult = new Dali::Actor((const Dali::Actor &)result);
26308   return jresult;
26309 }
26310
26311
26312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26313   void * jresult ;
26314   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26315   std::size_t arg2 ;
26316   Dali::Vector2 *result = 0 ;
26317
26318   arg1 = (Dali::TouchData *)jarg1;
26319   arg2 = (std::size_t)jarg2;
26320   {
26321     try {
26322       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26323     } catch (std::out_of_range& e) {
26324       {
26325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26326       };
26327     } catch (std::exception& e) {
26328       {
26329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26330       };
26331     } catch (...) {
26332       {
26333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26334       };
26335     }
26336   }
26337   jresult = (void *)result;
26338   return jresult;
26339 }
26340
26341
26342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26343   void * jresult ;
26344   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26345   std::size_t arg2 ;
26346   Dali::Vector2 *result = 0 ;
26347
26348   arg1 = (Dali::TouchData *)jarg1;
26349   arg2 = (std::size_t)jarg2;
26350   {
26351     try {
26352       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26353     } catch (std::out_of_range& e) {
26354       {
26355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26356       };
26357     } catch (std::exception& e) {
26358       {
26359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26360       };
26361     } catch (...) {
26362       {
26363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26364       };
26365     }
26366   }
26367   jresult = (void *)result;
26368   return jresult;
26369 }
26370
26371
26372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26373   float jresult ;
26374   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26375   std::size_t arg2 ;
26376   float result;
26377
26378   arg1 = (Dali::TouchData *)jarg1;
26379   arg2 = (std::size_t)jarg2;
26380   {
26381     try {
26382       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26383     } catch (std::out_of_range& e) {
26384       {
26385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26386       };
26387     } catch (std::exception& e) {
26388       {
26389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26390       };
26391     } catch (...) {
26392       {
26393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26394       };
26395     }
26396   }
26397   jresult = result;
26398   return jresult;
26399 }
26400
26401
26402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26403   void * jresult ;
26404   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26405   std::size_t arg2 ;
26406   Dali::Vector2 *result = 0 ;
26407
26408   arg1 = (Dali::TouchData *)jarg1;
26409   arg2 = (std::size_t)jarg2;
26410   {
26411     try {
26412       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26413     } catch (std::out_of_range& e) {
26414       {
26415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26416       };
26417     } catch (std::exception& e) {
26418       {
26419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26420       };
26421     } catch (...) {
26422       {
26423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26424       };
26425     }
26426   }
26427   jresult = (void *)result;
26428   return jresult;
26429 }
26430
26431
26432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26433   float jresult ;
26434   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26435   std::size_t arg2 ;
26436   float result;
26437
26438   arg1 = (Dali::TouchData *)jarg1;
26439   arg2 = (std::size_t)jarg2;
26440   {
26441     try {
26442       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26443     } catch (std::out_of_range& e) {
26444       {
26445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26446       };
26447     } catch (std::exception& e) {
26448       {
26449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26450       };
26451     } catch (...) {
26452       {
26453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26454       };
26455     }
26456   }
26457   jresult = result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26463   void * jresult ;
26464   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26465   std::size_t arg2 ;
26466   Dali::Degree result;
26467
26468   arg1 = (Dali::TouchData *)jarg1;
26469   arg2 = (std::size_t)jarg2;
26470   {
26471     try {
26472       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26473     } catch (std::out_of_range& e) {
26474       {
26475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26476       };
26477     } catch (std::exception& e) {
26478       {
26479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26484       };
26485     }
26486   }
26487   jresult = new Dali::Degree((const Dali::Degree &)result);
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26493   void * jresult ;
26494   Dali::GestureDetector *result = 0 ;
26495
26496   {
26497     try {
26498       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26499     } catch (std::out_of_range& e) {
26500       {
26501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26502       };
26503     } catch (std::exception& e) {
26504       {
26505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26506       };
26507     } catch (...) {
26508       {
26509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26510       };
26511     }
26512   }
26513   jresult = (void *)result;
26514   return jresult;
26515 }
26516
26517
26518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26519   void * jresult ;
26520   Dali::BaseHandle arg1 ;
26521   Dali::BaseHandle *argp1 ;
26522   Dali::GestureDetector result;
26523
26524   argp1 = (Dali::BaseHandle *)jarg1;
26525   if (!argp1) {
26526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26527     return 0;
26528   }
26529   arg1 = *argp1;
26530   {
26531     try {
26532       result = Dali::GestureDetector::DownCast(arg1);
26533     } catch (std::out_of_range& e) {
26534       {
26535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26536       };
26537     } catch (std::exception& e) {
26538       {
26539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26540       };
26541     } catch (...) {
26542       {
26543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26544       };
26545     }
26546   }
26547   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26548   return jresult;
26549 }
26550
26551
26552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26553   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26554
26555   arg1 = (Dali::GestureDetector *)jarg1;
26556   {
26557     try {
26558       delete arg1;
26559     } catch (std::out_of_range& e) {
26560       {
26561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26562       };
26563     } catch (std::exception& e) {
26564       {
26565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26566       };
26567     } catch (...) {
26568       {
26569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26570       };
26571     }
26572   }
26573 }
26574
26575
26576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26577   void * jresult ;
26578   Dali::GestureDetector *arg1 = 0 ;
26579   Dali::GestureDetector *result = 0 ;
26580
26581   arg1 = (Dali::GestureDetector *)jarg1;
26582   if (!arg1) {
26583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26584     return 0;
26585   }
26586   {
26587     try {
26588       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26589     } catch (std::out_of_range& e) {
26590       {
26591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26592       };
26593     } catch (std::exception& e) {
26594       {
26595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26596       };
26597     } catch (...) {
26598       {
26599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26600       };
26601     }
26602   }
26603   jresult = (void *)result;
26604   return jresult;
26605 }
26606
26607
26608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26609   void * jresult ;
26610   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26611   Dali::GestureDetector *arg2 = 0 ;
26612   Dali::GestureDetector *result = 0 ;
26613
26614   arg1 = (Dali::GestureDetector *)jarg1;
26615   arg2 = (Dali::GestureDetector *)jarg2;
26616   if (!arg2) {
26617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26618     return 0;
26619   }
26620   {
26621     try {
26622       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26623     } catch (std::out_of_range& e) {
26624       {
26625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26626       };
26627     } catch (std::exception& e) {
26628       {
26629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26630       };
26631     } catch (...) {
26632       {
26633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26634       };
26635     }
26636   }
26637   jresult = (void *)result;
26638   return jresult;
26639 }
26640
26641
26642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26643   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26644   Dali::Actor arg2 ;
26645   Dali::Actor *argp2 ;
26646
26647   arg1 = (Dali::GestureDetector *)jarg1;
26648   argp2 = (Dali::Actor *)jarg2;
26649   if (!argp2) {
26650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26651     return ;
26652   }
26653   arg2 = *argp2;
26654   {
26655     try {
26656       (arg1)->Attach(arg2);
26657     } catch (std::out_of_range& e) {
26658       {
26659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26660       };
26661     } catch (std::exception& e) {
26662       {
26663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26664       };
26665     } catch (...) {
26666       {
26667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26668       };
26669     }
26670   }
26671 }
26672
26673
26674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26675   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26676   Dali::Actor arg2 ;
26677   Dali::Actor *argp2 ;
26678
26679   arg1 = (Dali::GestureDetector *)jarg1;
26680   argp2 = (Dali::Actor *)jarg2;
26681   if (!argp2) {
26682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26683     return ;
26684   }
26685   arg2 = *argp2;
26686   {
26687     try {
26688       (arg1)->Detach(arg2);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26700       };
26701     }
26702   }
26703 }
26704
26705
26706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26707   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26708
26709   arg1 = (Dali::GestureDetector *)jarg1;
26710   {
26711     try {
26712       (arg1)->DetachAll();
26713     } catch (std::out_of_range& e) {
26714       {
26715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26716       };
26717     } catch (std::exception& e) {
26718       {
26719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26720       };
26721     } catch (...) {
26722       {
26723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26724       };
26725     }
26726   }
26727 }
26728
26729
26730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26731   unsigned long jresult ;
26732   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26733   size_t result;
26734
26735   arg1 = (Dali::GestureDetector *)jarg1;
26736   {
26737     try {
26738       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26739     } catch (std::out_of_range& e) {
26740       {
26741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26742       };
26743     } catch (std::exception& e) {
26744       {
26745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26746       };
26747     } catch (...) {
26748       {
26749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26750       };
26751     }
26752   }
26753   jresult = (unsigned long)result;
26754   return jresult;
26755 }
26756
26757
26758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26759   void * jresult ;
26760   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26761   size_t arg2 ;
26762   Dali::Actor result;
26763
26764   arg1 = (Dali::GestureDetector *)jarg1;
26765   arg2 = (size_t)jarg2;
26766   {
26767     try {
26768       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26769     } catch (std::out_of_range& e) {
26770       {
26771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26772       };
26773     } catch (std::exception& e) {
26774       {
26775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26776       };
26777     } catch (...) {
26778       {
26779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26780       };
26781     }
26782   }
26783   jresult = new Dali::Actor((const Dali::Actor &)result);
26784   return jresult;
26785 }
26786
26787
26788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26789   void * jresult ;
26790   Dali::Gesture *arg1 = 0 ;
26791   Dali::Gesture *result = 0 ;
26792
26793   arg1 = (Dali::Gesture *)jarg1;
26794   if (!arg1) {
26795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26796     return 0;
26797   }
26798   {
26799     try {
26800       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26801     } catch (std::out_of_range& e) {
26802       {
26803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26804       };
26805     } catch (std::exception& e) {
26806       {
26807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26808       };
26809     } catch (...) {
26810       {
26811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26812       };
26813     }
26814   }
26815   jresult = (void *)result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26821   void * jresult ;
26822   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26823   Dali::Gesture *arg2 = 0 ;
26824   Dali::Gesture *result = 0 ;
26825
26826   arg1 = (Dali::Gesture *)jarg1;
26827   arg2 = (Dali::Gesture *)jarg2;
26828   if (!arg2) {
26829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26830     return 0;
26831   }
26832   {
26833     try {
26834       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26835     } catch (std::out_of_range& e) {
26836       {
26837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (std::exception& e) {
26840       {
26841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849   jresult = (void *)result;
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26855   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26856
26857   arg1 = (Dali::Gesture *)jarg1;
26858   {
26859     try {
26860       delete arg1;
26861     } catch (std::out_of_range& e) {
26862       {
26863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26864       };
26865     } catch (std::exception& e) {
26866       {
26867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26868       };
26869     } catch (...) {
26870       {
26871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26872       };
26873     }
26874   }
26875 }
26876
26877
26878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26879   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26880   Dali::Gesture::Type arg2 ;
26881
26882   arg1 = (Dali::Gesture *)jarg1;
26883   arg2 = (Dali::Gesture::Type)jarg2;
26884   if (arg1) (arg1)->type = arg2;
26885 }
26886
26887
26888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26889   int jresult ;
26890   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26891   Dali::Gesture::Type result;
26892
26893   arg1 = (Dali::Gesture *)jarg1;
26894   result = (Dali::Gesture::Type) ((arg1)->type);
26895   jresult = (int)result;
26896   return jresult;
26897 }
26898
26899
26900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26901   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26902   Dali::Gesture::State arg2 ;
26903
26904   arg1 = (Dali::Gesture *)jarg1;
26905   arg2 = (Dali::Gesture::State)jarg2;
26906   if (arg1) (arg1)->state = arg2;
26907 }
26908
26909
26910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26911   int jresult ;
26912   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26913   Dali::Gesture::State result;
26914
26915   arg1 = (Dali::Gesture *)jarg1;
26916   result = (Dali::Gesture::State) ((arg1)->state);
26917   jresult = (int)result;
26918   return jresult;
26919 }
26920
26921
26922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26923   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26924   unsigned int arg2 ;
26925
26926   arg1 = (Dali::Gesture *)jarg1;
26927   arg2 = (unsigned int)jarg2;
26928   if (arg1) (arg1)->time = arg2;
26929 }
26930
26931
26932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26933   unsigned int jresult ;
26934   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26935   unsigned int result;
26936
26937   arg1 = (Dali::Gesture *)jarg1;
26938   result = (unsigned int) ((arg1)->time);
26939   jresult = result;
26940   return jresult;
26941 }
26942
26943
26944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26945   void * jresult ;
26946   Dali::HoverEvent *result = 0 ;
26947
26948   {
26949     try {
26950       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26951     } catch (std::out_of_range& e) {
26952       {
26953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26954       };
26955     } catch (std::exception& e) {
26956       {
26957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26958       };
26959     } catch (...) {
26960       {
26961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26962       };
26963     }
26964   }
26965   jresult = (void *)result;
26966   return jresult;
26967 }
26968
26969
26970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26971   void * jresult ;
26972   unsigned long arg1 ;
26973   Dali::HoverEvent *result = 0 ;
26974
26975   arg1 = (unsigned long)jarg1;
26976   {
26977     try {
26978       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26979     } catch (std::out_of_range& e) {
26980       {
26981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26982       };
26983     } catch (std::exception& e) {
26984       {
26985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26986       };
26987     } catch (...) {
26988       {
26989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26990       };
26991     }
26992   }
26993   jresult = (void *)result;
26994   return jresult;
26995 }
26996
26997
26998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26999   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27000
27001   arg1 = (Dali::HoverEvent *)jarg1;
27002   {
27003     try {
27004       delete arg1;
27005     } catch (std::out_of_range& e) {
27006       {
27007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27008       };
27009     } catch (std::exception& e) {
27010       {
27011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27012       };
27013     } catch (...) {
27014       {
27015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27016       };
27017     }
27018   }
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27023   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27024   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27025
27026   arg1 = (Dali::HoverEvent *)jarg1;
27027   arg2 = (Dali::TouchPointContainer *)jarg2;
27028   if (arg1) (arg1)->points = *arg2;
27029 }
27030
27031
27032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27033   void * jresult ;
27034   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27035   Dali::TouchPointContainer *result = 0 ;
27036
27037   arg1 = (Dali::HoverEvent *)jarg1;
27038   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27039   jresult = (void *)result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27045   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27046   unsigned long arg2 ;
27047
27048   arg1 = (Dali::HoverEvent *)jarg1;
27049   arg2 = (unsigned long)jarg2;
27050   if (arg1) (arg1)->time = arg2;
27051 }
27052
27053
27054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27055   unsigned long jresult ;
27056   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27057   unsigned long result;
27058
27059   arg1 = (Dali::HoverEvent *)jarg1;
27060   result = (unsigned long) ((arg1)->time);
27061   jresult = (unsigned long)result;
27062   return jresult;
27063 }
27064
27065
27066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27067   unsigned int jresult ;
27068   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27069   unsigned int result;
27070
27071   arg1 = (Dali::HoverEvent *)jarg1;
27072   {
27073     try {
27074       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27075     } catch (std::out_of_range& e) {
27076       {
27077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27078       };
27079     } catch (std::exception& e) {
27080       {
27081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (...) {
27084       {
27085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27086       };
27087     }
27088   }
27089   jresult = result;
27090   return jresult;
27091 }
27092
27093
27094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27095   void * jresult ;
27096   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27097   unsigned int arg2 ;
27098   Dali::TouchPoint *result = 0 ;
27099
27100   arg1 = (Dali::HoverEvent *)jarg1;
27101   arg2 = (unsigned int)jarg2;
27102   {
27103     try {
27104       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27105     } catch (std::out_of_range& e) {
27106       {
27107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27108       };
27109     } catch (std::exception& e) {
27110       {
27111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27112       };
27113     } catch (...) {
27114       {
27115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27116       };
27117     }
27118   }
27119   jresult = (void *)result;
27120   return jresult;
27121 }
27122
27123
27124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27125   void * jresult ;
27126   Dali::KeyEvent *result = 0 ;
27127
27128   {
27129     try {
27130       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27131     } catch (std::out_of_range& e) {
27132       {
27133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27134       };
27135     } catch (std::exception& e) {
27136       {
27137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27138       };
27139     } catch (...) {
27140       {
27141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27142       };
27143     }
27144   }
27145   jresult = (void *)result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27151   void * jresult ;
27152   std::string *arg1 = 0 ;
27153   std::string *arg2 = 0 ;
27154   int arg3 ;
27155   int arg4 ;
27156   unsigned long arg5 ;
27157   Dali::KeyEvent::State *arg6 = 0 ;
27158   Dali::KeyEvent::State temp6 ;
27159   Dali::KeyEvent *result = 0 ;
27160
27161   if (!jarg1) {
27162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27163     return 0;
27164   }
27165   std::string arg1_str(jarg1);
27166   arg1 = &arg1_str;
27167   if (!jarg2) {
27168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27169     return 0;
27170   }
27171   std::string arg2_str(jarg2);
27172   arg2 = &arg2_str;
27173   arg3 = (int)jarg3;
27174   arg4 = (int)jarg4;
27175   arg5 = (unsigned long)jarg5;
27176   temp6 = (Dali::KeyEvent::State)jarg6;
27177   arg6 = &temp6;
27178   {
27179     try {
27180       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (...) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27192       };
27193     }
27194   }
27195   jresult = (void *)result;
27196
27197   //argout typemap for const std::string&
27198
27199
27200   //argout typemap for const std::string&
27201
27202   return jresult;
27203 }
27204
27205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27206   void * jresult ;
27207   Dali::KeyEvent *arg1 = 0 ;
27208   Dali::KeyEvent *result = 0 ;
27209
27210   arg1 = (Dali::KeyEvent *)jarg1;
27211   if (!arg1) {
27212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27213     return 0;
27214   }
27215   {
27216     try {
27217       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27225       };
27226     } catch (...) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27229       };
27230     }
27231   }
27232   jresult = (void *)result;
27233   return jresult;
27234 }
27235
27236
27237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27238   void * jresult ;
27239   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27240   Dali::KeyEvent *arg2 = 0 ;
27241   Dali::KeyEvent *result = 0 ;
27242
27243   arg1 = (Dali::KeyEvent *)jarg1;
27244   arg2 = (Dali::KeyEvent *)jarg2;
27245   if (!arg2) {
27246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27247     return 0;
27248   }
27249   {
27250     try {
27251       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27252     } catch (std::out_of_range& e) {
27253       {
27254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27255       };
27256     } catch (std::exception& e) {
27257       {
27258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27259       };
27260     } catch (...) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27263       };
27264     }
27265   }
27266   jresult = (void *)result;
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27272   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27273
27274   arg1 = (Dali::KeyEvent *)jarg1;
27275   {
27276     try {
27277       delete arg1;
27278     } catch (std::out_of_range& e) {
27279       {
27280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27281       };
27282     } catch (std::exception& e) {
27283       {
27284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27285       };
27286     } catch (...) {
27287       {
27288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27289       };
27290     }
27291   }
27292 }
27293
27294
27295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27296   unsigned int jresult ;
27297   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27298   bool result;
27299
27300   arg1 = (Dali::KeyEvent *)jarg1;
27301   {
27302     try {
27303       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27304     } catch (std::out_of_range& e) {
27305       {
27306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27307       };
27308     } catch (std::exception& e) {
27309       {
27310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27311       };
27312     } catch (...) {
27313       {
27314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27315       };
27316     }
27317   }
27318   jresult = result;
27319   return jresult;
27320 }
27321
27322
27323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27324   unsigned int jresult ;
27325   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27326   bool result;
27327
27328   arg1 = (Dali::KeyEvent *)jarg1;
27329   {
27330     try {
27331       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27332     } catch (std::out_of_range& e) {
27333       {
27334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (std::exception& e) {
27337       {
27338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27343       };
27344     }
27345   }
27346   jresult = result;
27347   return jresult;
27348 }
27349
27350
27351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27352   unsigned int jresult ;
27353   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27354   bool result;
27355
27356   arg1 = (Dali::KeyEvent *)jarg1;
27357   {
27358     try {
27359       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27360     } catch (std::out_of_range& e) {
27361       {
27362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27363       };
27364     } catch (std::exception& e) {
27365       {
27366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (...) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27371       };
27372     }
27373   }
27374   jresult = result;
27375   return jresult;
27376 }
27377
27378
27379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27380   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27381   std::string *arg2 = 0 ;
27382
27383   arg1 = (Dali::KeyEvent *)jarg1;
27384   if (!jarg2) {
27385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27386     return ;
27387   }
27388   std::string arg2_str(jarg2);
27389   arg2 = &arg2_str;
27390   if (arg1) (arg1)->keyPressedName = *arg2;
27391
27392   //argout typemap for const std::string&
27393
27394 }
27395
27396
27397 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27398   char * jresult ;
27399   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27400   std::string *result = 0 ;
27401
27402   arg1 = (Dali::KeyEvent *)jarg1;
27403   result = (std::string *) & ((arg1)->keyPressedName);
27404   jresult = SWIG_csharp_string_callback(result->c_str());
27405   return jresult;
27406 }
27407
27408
27409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27410   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27411   std::string *arg2 = 0 ;
27412
27413   arg1 = (Dali::KeyEvent *)jarg1;
27414   if (!jarg2) {
27415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27416     return ;
27417   }
27418   std::string arg2_str(jarg2);
27419   arg2 = &arg2_str;
27420   if (arg1) (arg1)->keyPressed = *arg2;
27421
27422   //argout typemap for const std::string&
27423
27424 }
27425
27426
27427 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27428   char * jresult ;
27429   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27430   std::string *result = 0 ;
27431
27432   arg1 = (Dali::KeyEvent *)jarg1;
27433   result = (std::string *) & ((arg1)->keyPressed);
27434   jresult = SWIG_csharp_string_callback(result->c_str());
27435   return jresult;
27436 }
27437
27438
27439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27440   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27441   int arg2 ;
27442
27443   arg1 = (Dali::KeyEvent *)jarg1;
27444   arg2 = (int)jarg2;
27445   if (arg1) (arg1)->keyCode = arg2;
27446 }
27447
27448
27449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27450   int jresult ;
27451   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27452   int result;
27453
27454   arg1 = (Dali::KeyEvent *)jarg1;
27455   result = (int) ((arg1)->keyCode);
27456   jresult = result;
27457   return jresult;
27458 }
27459
27460
27461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27462   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27463   int arg2 ;
27464
27465   arg1 = (Dali::KeyEvent *)jarg1;
27466   arg2 = (int)jarg2;
27467   if (arg1) (arg1)->keyModifier = arg2;
27468 }
27469
27470
27471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27472   int jresult ;
27473   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27474   int result;
27475
27476   arg1 = (Dali::KeyEvent *)jarg1;
27477   result = (int) ((arg1)->keyModifier);
27478   jresult = result;
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27484   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27485   unsigned long arg2 ;
27486
27487   arg1 = (Dali::KeyEvent *)jarg1;
27488   arg2 = (unsigned long)jarg2;
27489   if (arg1) (arg1)->time = arg2;
27490 }
27491
27492
27493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27494   unsigned long jresult ;
27495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27496   unsigned long result;
27497
27498   arg1 = (Dali::KeyEvent *)jarg1;
27499   result = (unsigned long) ((arg1)->time);
27500   jresult = (unsigned long)result;
27501   return jresult;
27502 }
27503
27504
27505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   Dali::KeyEvent::State arg2 ;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   arg2 = (Dali::KeyEvent::State)jarg2;
27511   if (arg1) (arg1)->state = arg2;
27512 }
27513
27514
27515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27516   int jresult ;
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   Dali::KeyEvent::State result;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   result = (Dali::KeyEvent::State) ((arg1)->state);
27522   jresult = (int)result;
27523   return jresult;
27524 }
27525
27526
27527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27528   void * jresult ;
27529   Dali::LongPressGestureDetector *result = 0 ;
27530
27531   {
27532     try {
27533       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27541       };
27542     } catch (...) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27545       };
27546     }
27547   }
27548   jresult = (void *)result;
27549   return jresult;
27550 }
27551
27552
27553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27554   void * jresult ;
27555   Dali::LongPressGestureDetector result;
27556
27557   {
27558     try {
27559       result = Dali::LongPressGestureDetector::New();
27560     } catch (std::out_of_range& e) {
27561       {
27562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27563       };
27564     } catch (std::exception& e) {
27565       {
27566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27567       };
27568     } catch (...) {
27569       {
27570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27571       };
27572     }
27573   }
27574   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27575   return jresult;
27576 }
27577
27578
27579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27580   void * jresult ;
27581   unsigned int arg1 ;
27582   Dali::LongPressGestureDetector result;
27583
27584   arg1 = (unsigned int)jarg1;
27585   {
27586     try {
27587       result = Dali::LongPressGestureDetector::New(arg1);
27588     } catch (std::out_of_range& e) {
27589       {
27590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27591       };
27592     } catch (std::exception& e) {
27593       {
27594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27595       };
27596     } catch (...) {
27597       {
27598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27599       };
27600     }
27601   }
27602   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27603   return jresult;
27604 }
27605
27606
27607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27608   void * jresult ;
27609   unsigned int arg1 ;
27610   unsigned int arg2 ;
27611   Dali::LongPressGestureDetector result;
27612
27613   arg1 = (unsigned int)jarg1;
27614   arg2 = (unsigned int)jarg2;
27615   {
27616     try {
27617       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27618     } catch (std::out_of_range& e) {
27619       {
27620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27621       };
27622     } catch (std::exception& e) {
27623       {
27624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27625       };
27626     } catch (...) {
27627       {
27628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27629       };
27630     }
27631   }
27632   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27633   return jresult;
27634 }
27635
27636
27637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27638   void * jresult ;
27639   Dali::BaseHandle arg1 ;
27640   Dali::BaseHandle *argp1 ;
27641   Dali::LongPressGestureDetector result;
27642
27643   argp1 = (Dali::BaseHandle *)jarg1;
27644   if (!argp1) {
27645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27646     return 0;
27647   }
27648   arg1 = *argp1;
27649   {
27650     try {
27651       result = Dali::LongPressGestureDetector::DownCast(arg1);
27652     } catch (std::out_of_range& e) {
27653       {
27654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27655       };
27656     } catch (std::exception& e) {
27657       {
27658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27659       };
27660     } catch (...) {
27661       {
27662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27663       };
27664     }
27665   }
27666   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27667   return jresult;
27668 }
27669
27670
27671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27672   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27673
27674   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27675   {
27676     try {
27677       delete arg1;
27678     } catch (std::out_of_range& e) {
27679       {
27680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27681       };
27682     } catch (std::exception& e) {
27683       {
27684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27685       };
27686     } catch (...) {
27687       {
27688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27689       };
27690     }
27691   }
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27696   void * jresult ;
27697   Dali::LongPressGestureDetector *arg1 = 0 ;
27698   Dali::LongPressGestureDetector *result = 0 ;
27699
27700   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27701   if (!arg1) {
27702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27703     return 0;
27704   }
27705   {
27706     try {
27707       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27708     } catch (std::out_of_range& e) {
27709       {
27710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27711       };
27712     } catch (std::exception& e) {
27713       {
27714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27715       };
27716     } catch (...) {
27717       {
27718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27719       };
27720     }
27721   }
27722   jresult = (void *)result;
27723   return jresult;
27724 }
27725
27726
27727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27728   void * jresult ;
27729   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27730   Dali::LongPressGestureDetector *arg2 = 0 ;
27731   Dali::LongPressGestureDetector *result = 0 ;
27732
27733   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27734   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27735   if (!arg2) {
27736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27737     return 0;
27738   }
27739   {
27740     try {
27741       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27742     } catch (std::out_of_range& e) {
27743       {
27744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27745       };
27746     } catch (std::exception& e) {
27747       {
27748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27749       };
27750     } catch (...) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27753       };
27754     }
27755   }
27756   jresult = (void *)result;
27757   return jresult;
27758 }
27759
27760
27761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27762   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27763   unsigned int arg2 ;
27764
27765   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27766   arg2 = (unsigned int)jarg2;
27767   {
27768     try {
27769       (arg1)->SetTouchesRequired(arg2);
27770     } catch (std::out_of_range& e) {
27771       {
27772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27773       };
27774     } catch (std::exception& e) {
27775       {
27776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27777       };
27778     } catch (...) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27781       };
27782     }
27783   }
27784 }
27785
27786
27787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27788   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27789   unsigned int arg2 ;
27790   unsigned int arg3 ;
27791
27792   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27793   arg2 = (unsigned int)jarg2;
27794   arg3 = (unsigned int)jarg3;
27795   {
27796     try {
27797       (arg1)->SetTouchesRequired(arg2,arg3);
27798     } catch (std::out_of_range& e) {
27799       {
27800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27801       };
27802     } catch (std::exception& e) {
27803       {
27804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27805       };
27806     } catch (...) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27809       };
27810     }
27811   }
27812 }
27813
27814
27815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27816   unsigned int jresult ;
27817   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27818   unsigned int result;
27819
27820   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27821   {
27822     try {
27823       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27824     } catch (std::out_of_range& e) {
27825       {
27826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27827       };
27828     } catch (std::exception& e) {
27829       {
27830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27831       };
27832     } catch (...) {
27833       {
27834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27835       };
27836     }
27837   }
27838   jresult = result;
27839   return jresult;
27840 }
27841
27842
27843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27844   unsigned int jresult ;
27845   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27846   unsigned int result;
27847
27848   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27849   {
27850     try {
27851       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27852     } catch (std::out_of_range& e) {
27853       {
27854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (std::exception& e) {
27857       {
27858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866   jresult = result;
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27872   void * jresult ;
27873   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27874   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27875
27876   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27877   {
27878     try {
27879       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27880     } catch (std::out_of_range& e) {
27881       {
27882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27883       };
27884     } catch (std::exception& e) {
27885       {
27886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27887       };
27888     } catch (...) {
27889       {
27890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27891       };
27892     }
27893   }
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27900   void * jresult ;
27901   Dali::Gesture::State arg1 ;
27902   Dali::LongPressGesture *result = 0 ;
27903
27904   arg1 = (Dali::Gesture::State)jarg1;
27905   {
27906     try {
27907       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27908     } catch (std::out_of_range& e) {
27909       {
27910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (std::exception& e) {
27913       {
27914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27915       };
27916     } catch (...) {
27917       {
27918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27919       };
27920     }
27921   }
27922   jresult = (void *)result;
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27928   void * jresult ;
27929   Dali::LongPressGesture *arg1 = 0 ;
27930   Dali::LongPressGesture *result = 0 ;
27931
27932   arg1 = (Dali::LongPressGesture *)jarg1;
27933   if (!arg1) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27935     return 0;
27936   }
27937   {
27938     try {
27939       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27940     } catch (std::out_of_range& e) {
27941       {
27942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27943       };
27944     } catch (std::exception& e) {
27945       {
27946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27947       };
27948     } catch (...) {
27949       {
27950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27951       };
27952     }
27953   }
27954   jresult = (void *)result;
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27960   void * jresult ;
27961   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27962   Dali::LongPressGesture *arg2 = 0 ;
27963   Dali::LongPressGesture *result = 0 ;
27964
27965   arg1 = (Dali::LongPressGesture *)jarg1;
27966   arg2 = (Dali::LongPressGesture *)jarg2;
27967   if (!arg2) {
27968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27969     return 0;
27970   }
27971   {
27972     try {
27973       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27974     } catch (std::out_of_range& e) {
27975       {
27976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27977       };
27978     } catch (std::exception& e) {
27979       {
27980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (...) {
27983       {
27984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27985       };
27986     }
27987   }
27988   jresult = (void *)result;
27989   return jresult;
27990 }
27991
27992
27993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27994   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27995
27996   arg1 = (Dali::LongPressGesture *)jarg1;
27997   {
27998     try {
27999       delete arg1;
28000     } catch (std::out_of_range& e) {
28001       {
28002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28003       };
28004     } catch (std::exception& e) {
28005       {
28006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28007       };
28008     } catch (...) {
28009       {
28010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28011       };
28012     }
28013   }
28014 }
28015
28016
28017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28018   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28019   unsigned int arg2 ;
28020
28021   arg1 = (Dali::LongPressGesture *)jarg1;
28022   arg2 = (unsigned int)jarg2;
28023   if (arg1) (arg1)->numberOfTouches = arg2;
28024 }
28025
28026
28027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28028   unsigned int jresult ;
28029   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28030   unsigned int result;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   result = (unsigned int) ((arg1)->numberOfTouches);
28034   jresult = result;
28035   return jresult;
28036 }
28037
28038
28039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28040   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28041   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28042
28043   arg1 = (Dali::LongPressGesture *)jarg1;
28044   arg2 = (Dali::Vector2 *)jarg2;
28045   if (arg1) (arg1)->screenPoint = *arg2;
28046 }
28047
28048
28049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28050   void * jresult ;
28051   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28052   Dali::Vector2 *result = 0 ;
28053
28054   arg1 = (Dali::LongPressGesture *)jarg1;
28055   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28056   jresult = (void *)result;
28057   return jresult;
28058 }
28059
28060
28061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28062   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28063   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (Dali::Vector2 *)jarg2;
28067   if (arg1) (arg1)->localPoint = *arg2;
28068 }
28069
28070
28071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28072   void * jresult ;
28073   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28074   Dali::Vector2 *result = 0 ;
28075
28076   arg1 = (Dali::LongPressGesture *)jarg1;
28077   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28078   jresult = (void *)result;
28079   return jresult;
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28084   void * jresult ;
28085   Dali::WheelEvent *result = 0 ;
28086
28087   {
28088     try {
28089       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28090     } catch (std::out_of_range& e) {
28091       {
28092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28093       };
28094     } catch (std::exception& e) {
28095       {
28096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28097       };
28098     } catch (...) {
28099       {
28100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28101       };
28102     }
28103   }
28104   jresult = (void *)result;
28105   return jresult;
28106 }
28107
28108
28109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28110   void * jresult ;
28111   Dali::WheelEvent::Type arg1 ;
28112   int arg2 ;
28113   unsigned int arg3 ;
28114   Dali::Vector2 arg4 ;
28115   int arg5 ;
28116   unsigned int arg6 ;
28117   Dali::Vector2 *argp4 ;
28118   Dali::WheelEvent *result = 0 ;
28119
28120   arg1 = (Dali::WheelEvent::Type)jarg1;
28121   arg2 = (int)jarg2;
28122   arg3 = (unsigned int)jarg3;
28123   argp4 = (Dali::Vector2 *)jarg4;
28124   if (!argp4) {
28125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28126     return 0;
28127   }
28128   arg4 = *argp4;
28129   arg5 = (int)jarg5;
28130   arg6 = (unsigned int)jarg6;
28131   {
28132     try {
28133       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28134     } catch (std::out_of_range& e) {
28135       {
28136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28137       };
28138     } catch (std::exception& e) {
28139       {
28140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28141       };
28142     } catch (...) {
28143       {
28144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28145       };
28146     }
28147   }
28148   jresult = (void *)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28154   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28155
28156   arg1 = (Dali::WheelEvent *)jarg1;
28157   {
28158     try {
28159       delete arg1;
28160     } catch (std::out_of_range& e) {
28161       {
28162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28163       };
28164     } catch (std::exception& e) {
28165       {
28166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28167       };
28168     } catch (...) {
28169       {
28170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28171       };
28172     }
28173   }
28174 }
28175
28176
28177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28178   unsigned int jresult ;
28179   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28180   bool result;
28181
28182   arg1 = (Dali::WheelEvent *)jarg1;
28183   {
28184     try {
28185       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28186     } catch (std::out_of_range& e) {
28187       {
28188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28189       };
28190     } catch (std::exception& e) {
28191       {
28192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28197       };
28198     }
28199   }
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28206   unsigned int jresult ;
28207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28208   bool result;
28209
28210   arg1 = (Dali::WheelEvent *)jarg1;
28211   {
28212     try {
28213       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28214     } catch (std::out_of_range& e) {
28215       {
28216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28217       };
28218     } catch (std::exception& e) {
28219       {
28220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28221       };
28222     } catch (...) {
28223       {
28224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28225       };
28226     }
28227   }
28228   jresult = result;
28229   return jresult;
28230 }
28231
28232
28233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28234   unsigned int jresult ;
28235   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28236   bool result;
28237
28238   arg1 = (Dali::WheelEvent *)jarg1;
28239   {
28240     try {
28241       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28242     } catch (std::out_of_range& e) {
28243       {
28244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28245       };
28246     } catch (std::exception& e) {
28247       {
28248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28253       };
28254     }
28255   }
28256   jresult = result;
28257   return jresult;
28258 }
28259
28260
28261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28262   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28263   Dali::WheelEvent::Type arg2 ;
28264
28265   arg1 = (Dali::WheelEvent *)jarg1;
28266   arg2 = (Dali::WheelEvent::Type)jarg2;
28267   if (arg1) (arg1)->type = arg2;
28268 }
28269
28270
28271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28272   int jresult ;
28273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28274   Dali::WheelEvent::Type result;
28275
28276   arg1 = (Dali::WheelEvent *)jarg1;
28277   result = (Dali::WheelEvent::Type) ((arg1)->type);
28278   jresult = (int)result;
28279   return jresult;
28280 }
28281
28282
28283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28284   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28285   int arg2 ;
28286
28287   arg1 = (Dali::WheelEvent *)jarg1;
28288   arg2 = (int)jarg2;
28289   if (arg1) (arg1)->direction = arg2;
28290 }
28291
28292
28293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28294   int jresult ;
28295   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28296   int result;
28297
28298   arg1 = (Dali::WheelEvent *)jarg1;
28299   result = (int) ((arg1)->direction);
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28307   unsigned int arg2 ;
28308
28309   arg1 = (Dali::WheelEvent *)jarg1;
28310   arg2 = (unsigned int)jarg2;
28311   if (arg1) (arg1)->modifiers = arg2;
28312 }
28313
28314
28315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28316   unsigned int jresult ;
28317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28318   unsigned int result;
28319
28320   arg1 = (Dali::WheelEvent *)jarg1;
28321   result = (unsigned int) ((arg1)->modifiers);
28322   jresult = result;
28323   return jresult;
28324 }
28325
28326
28327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28329   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28330
28331   arg1 = (Dali::WheelEvent *)jarg1;
28332   arg2 = (Dali::Vector2 *)jarg2;
28333   if (arg1) (arg1)->point = *arg2;
28334 }
28335
28336
28337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28338   void * jresult ;
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   Dali::Vector2 *result = 0 ;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   result = (Dali::Vector2 *)& ((arg1)->point);
28344   jresult = (void *)result;
28345   return jresult;
28346 }
28347
28348
28349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   int arg2 ;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   arg2 = (int)jarg2;
28355   if (arg1) (arg1)->z = arg2;
28356 }
28357
28358
28359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28360   int jresult ;
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   int result;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   result = (int) ((arg1)->z);
28366   jresult = result;
28367   return jresult;
28368 }
28369
28370
28371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   unsigned int arg2 ;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   arg2 = (unsigned int)jarg2;
28377   if (arg1) (arg1)->timeStamp = arg2;
28378 }
28379
28380
28381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28382   unsigned int jresult ;
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   unsigned int result;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   result = (unsigned int) ((arg1)->timeStamp);
28388   jresult = result;
28389   return jresult;
28390 }
28391
28392 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28393   char * jresult ;
28394   Dali::KeyEvent *arg1 = 0 ;
28395   std::string result;
28396
28397   arg1 = (Dali::KeyEvent *)jarg1;
28398   if (!arg1) {
28399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28400     return 0;
28401   }
28402   {
28403     try {
28404       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28412       };
28413     } catch (...) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28416       };
28417     }
28418   }
28419   jresult = SWIG_csharp_string_callback((&result)->c_str());
28420   return jresult;
28421 }
28422
28423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28424   int jresult ;
28425   Dali::KeyEvent *arg1 = 0 ;
28426   Dali::DevelDevice::Class::Type result;
28427
28428   arg1 = (Dali::KeyEvent *)jarg1;
28429   if (!arg1) {
28430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28431     return 0;
28432   }
28433   {
28434     try {
28435       result = (Dali::DevelDevice::Class::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (...) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28447       };
28448     }
28449   }
28450   jresult = (int)result;
28451   return jresult;
28452 }
28453
28454
28455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28456   Dali::Actor arg1 ;
28457   Dali::Actor *argp1 ;
28458
28459   argp1 = (Dali::Actor *)jarg1;
28460   if (!argp1) {
28461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28462     return ;
28463   }
28464   arg1 = *argp1;
28465   {
28466     try {
28467       Dali::DevelActor::Raise(arg1);
28468     } catch (std::out_of_range& e) {
28469       {
28470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28471       };
28472     } catch (std::exception& e) {
28473       {
28474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28475       };
28476     } catch (...) {
28477       {
28478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28479       };
28480     }
28481   }
28482 }
28483
28484
28485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28486   Dali::Actor arg1 ;
28487   Dali::Actor *argp1 ;
28488
28489   argp1 = (Dali::Actor *)jarg1;
28490   if (!argp1) {
28491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28492     return ;
28493   }
28494   arg1 = *argp1;
28495   {
28496     try {
28497       Dali::DevelActor::Lower(arg1);
28498     } catch (std::out_of_range& e) {
28499       {
28500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28501       };
28502     } catch (std::exception& e) {
28503       {
28504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28505       };
28506     } catch (...) {
28507       {
28508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28509       };
28510     }
28511   }
28512 }
28513
28514
28515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28516   Dali::Actor arg1 ;
28517   Dali::Actor *argp1 ;
28518
28519   argp1 = (Dali::Actor *)jarg1;
28520   if (!argp1) {
28521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28522     return ;
28523   }
28524   arg1 = *argp1;
28525   {
28526     try {
28527       Dali::DevelActor::RaiseToTop(arg1);
28528     } catch (std::out_of_range& e) {
28529       {
28530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28531       };
28532     } catch (std::exception& e) {
28533       {
28534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28535       };
28536     } catch (...) {
28537       {
28538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28539       };
28540     }
28541   }
28542 }
28543
28544
28545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28546   Dali::Actor arg1 ;
28547   Dali::Actor *argp1 ;
28548
28549   argp1 = (Dali::Actor *)jarg1;
28550   if (!argp1) {
28551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28552     return ;
28553   }
28554   arg1 = *argp1;
28555   {
28556     try {
28557       Dali::DevelActor::LowerToBottom(arg1);
28558     } catch (std::out_of_range& e) {
28559       {
28560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28561       };
28562     } catch (std::exception& e) {
28563       {
28564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28565       };
28566     } catch (...) {
28567       {
28568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28569       };
28570     }
28571   }
28572 }
28573
28574
28575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28576   Dali::Actor arg1 ;
28577   Dali::Actor arg2 ;
28578   Dali::Actor *argp1 ;
28579   Dali::Actor *argp2 ;
28580
28581   argp1 = (Dali::Actor *)jarg1;
28582   if (!argp1) {
28583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28584     return ;
28585   }
28586   arg1 = *argp1;
28587   argp2 = (Dali::Actor *)jarg2;
28588   if (!argp2) {
28589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28590     return ;
28591   }
28592   arg2 = *argp2;
28593   {
28594     try {
28595       Dali::DevelActor::RaiseAbove(arg1,arg2);
28596     } catch (std::out_of_range& e) {
28597       {
28598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28599       };
28600     } catch (std::exception& e) {
28601       {
28602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28603       };
28604     } catch (...) {
28605       {
28606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28607       };
28608     }
28609   }
28610 }
28611
28612
28613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28614   Dali::Actor arg1 ;
28615   Dali::Actor arg2 ;
28616   Dali::Actor *argp1 ;
28617   Dali::Actor *argp2 ;
28618
28619   argp1 = (Dali::Actor *)jarg1;
28620   if (!argp1) {
28621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28622     return ;
28623   }
28624   arg1 = *argp1;
28625   argp2 = (Dali::Actor *)jarg2;
28626   if (!argp2) {
28627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28628     return ;
28629   }
28630   arg2 = *argp2;
28631   {
28632     try {
28633       Dali::DevelActor::LowerBelow(arg1,arg2);
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28641       };
28642     } catch (...) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28645       };
28646     }
28647   }
28648 }
28649
28650
28651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28652   void * jresult ;
28653   Dali::Actor arg1 ;
28654   Dali::Actor *argp1 ;
28655   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28656
28657   argp1 = (Dali::Actor *)jarg1;
28658   if (!argp1) {
28659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28660     return 0;
28661   }
28662   arg1 = *argp1;
28663   {
28664     try {
28665       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28666     } catch (std::out_of_range& e) {
28667       {
28668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28669       };
28670     } catch (std::exception& e) {
28671       {
28672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28673       };
28674     } catch (...) {
28675       {
28676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28677       };
28678     }
28679   }
28680   jresult = (void *)result;
28681   return jresult;
28682 }
28683
28684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28685   int jresult ;
28686   int result;
28687
28688   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28689   jresult = (int)result;
28690   return jresult;
28691 }
28692
28693
28694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28695   int jresult ;
28696   int result;
28697
28698   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28699   jresult = (int)result;
28700   return jresult;
28701 }
28702
28703
28704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28705   int jresult ;
28706   int result;
28707
28708   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28709   jresult = (int)result;
28710   return jresult;
28711 }
28712
28713
28714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28715   int jresult ;
28716   int result;
28717
28718   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28719   jresult = (int)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28725   int jresult ;
28726   int result;
28727
28728   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28729   jresult = (int)result;
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28735   int jresult ;
28736   int result;
28737
28738   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28739   jresult = (int)result;
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28745   int jresult ;
28746   int result;
28747
28748   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28749   jresult = (int)result;
28750   return jresult;
28751 }
28752
28753
28754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28755   int jresult ;
28756   int result;
28757
28758   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28759   jresult = (int)result;
28760   return jresult;
28761 }
28762
28763
28764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28765   int jresult ;
28766   int result;
28767
28768   result = (int)Dali::Actor::Property::SIZE;
28769   jresult = (int)result;
28770   return jresult;
28771 }
28772
28773
28774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28775   int jresult ;
28776   int result;
28777
28778   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28779   jresult = (int)result;
28780   return jresult;
28781 }
28782
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::POSITION;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::POSITION_X;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::POSITION_Y;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::POSITION_Z;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::WORLD_POSITION;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::ORIENTATION;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::SCALE;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::SCALE_X;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::SCALE_Y;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::SCALE_Z;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::WORLD_SCALE;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::VISIBLE;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::COLOR;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::COLOR_RED;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::COLOR_GREEN;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::COLOR_BLUE;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::WORLD_COLOR;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::NAME;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::SENSITIVE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29075   int jresult ;
29076   int result;
29077
29078   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29079   jresult = (int)result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29085   int jresult ;
29086   int result;
29087
29088   result = (int)Dali::Actor::Property::COLOR_MODE;
29089   jresult = (int)result;
29090   return jresult;
29091 }
29092
29093
29094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29095   int jresult ;
29096   int result;
29097
29098   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29099   jresult = (int)result;
29100   return jresult;
29101 }
29102
29103
29104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29105   int jresult ;
29106   int result;
29107
29108   result = (int)Dali::Actor::Property::DRAW_MODE;
29109   jresult = (int)result;
29110   return jresult;
29111 }
29112
29113
29114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29115   int jresult ;
29116   int result;
29117
29118   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29119   jresult = (int)result;
29120   return jresult;
29121 }
29122
29123
29124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29125   int jresult ;
29126   int result;
29127
29128   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29129   jresult = (int)result;
29130   return jresult;
29131 }
29132
29133
29134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29135   int jresult ;
29136   int result;
29137
29138   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29139   jresult = (int)result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29145   int jresult ;
29146   int result;
29147
29148   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29149   jresult = (int)result;
29150   return jresult;
29151 }
29152
29153
29154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29155   int jresult ;
29156   int result;
29157
29158   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29159   jresult = (int)result;
29160   return jresult;
29161 }
29162
29163
29164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29165   int jresult ;
29166   int result;
29167
29168   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29175   int jresult ;
29176   int result;
29177
29178   result = (int)Dali::Actor::Property::PADDING;
29179   jresult = (int)result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29185   int jresult ;
29186   int result;
29187
29188   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29189   jresult = (int)result;
29190   return jresult;
29191 }
29192
29193
29194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29195   int jresult ;
29196   int result;
29197
29198   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29199   jresult = (int)result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29205   int jresult ;
29206   int result;
29207
29208   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29209   jresult = (int)result;
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29215   int jresult ;
29216   int result;
29217
29218   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29219   jresult = (int)result;
29220   return jresult;
29221 }
29222
29223
29224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29225   void * jresult ;
29226   Dali::Actor::Property *result = 0 ;
29227
29228   {
29229     try {
29230       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29231     } catch (std::out_of_range& e) {
29232       {
29233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29234       };
29235     } catch (std::exception& e) {
29236       {
29237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29242       };
29243     }
29244   }
29245   jresult = (void *)result;
29246   return jresult;
29247 }
29248
29249
29250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29251   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29252
29253   arg1 = (Dali::Actor::Property *)jarg1;
29254   {
29255     try {
29256       delete arg1;
29257     } catch (std::out_of_range& e) {
29258       {
29259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29260       };
29261     } catch (std::exception& e) {
29262       {
29263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29264       };
29265     } catch (...) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29268       };
29269     }
29270   }
29271 }
29272
29273
29274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29275   void * jresult ;
29276   Dali::Actor *result = 0 ;
29277
29278   {
29279     try {
29280       result = (Dali::Actor *)new Dali::Actor();
29281     } catch (std::out_of_range& e) {
29282       {
29283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29284       };
29285     } catch (std::exception& e) {
29286       {
29287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29288       };
29289     } catch (...) {
29290       {
29291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29292       };
29293     }
29294   }
29295   jresult = (void *)result;
29296   return jresult;
29297 }
29298
29299
29300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29301   void * jresult ;
29302   Dali::Actor result;
29303
29304   {
29305     try {
29306       result = Dali::Actor::New();
29307     } catch (std::out_of_range& e) {
29308       {
29309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29310       };
29311     } catch (std::exception& e) {
29312       {
29313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29314       };
29315     } catch (...) {
29316       {
29317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29318       };
29319     }
29320   }
29321   jresult = new Dali::Actor((const Dali::Actor &)result);
29322   return jresult;
29323 }
29324
29325
29326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29327   void * jresult ;
29328   Dali::BaseHandle arg1 ;
29329   Dali::BaseHandle *argp1 ;
29330   Dali::Actor result;
29331
29332   argp1 = (Dali::BaseHandle *)jarg1;
29333   if (!argp1) {
29334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29335     return 0;
29336   }
29337   arg1 = *argp1;
29338   {
29339     try {
29340       result = Dali::Actor::DownCast(arg1);
29341     } catch (std::out_of_range& e) {
29342       {
29343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29344       };
29345     } catch (std::exception& e) {
29346       {
29347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29348       };
29349     } catch (...) {
29350       {
29351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29352       };
29353     }
29354   }
29355   jresult = new Dali::Actor((const Dali::Actor &)result);
29356   return jresult;
29357 }
29358
29359
29360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29362
29363   arg1 = (Dali::Actor *)jarg1;
29364   {
29365     try {
29366       delete arg1;
29367     } catch (std::out_of_range& e) {
29368       {
29369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29370       };
29371     } catch (std::exception& e) {
29372       {
29373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29374       };
29375     } catch (...) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29378       };
29379     }
29380   }
29381 }
29382
29383
29384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29385   void * jresult ;
29386   Dali::Actor *arg1 = 0 ;
29387   Dali::Actor *result = 0 ;
29388
29389   arg1 = (Dali::Actor *)jarg1;
29390   if (!arg1) {
29391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29392     return 0;
29393   }
29394   {
29395     try {
29396       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29397     } catch (std::out_of_range& e) {
29398       {
29399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29400       };
29401     } catch (std::exception& e) {
29402       {
29403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29404       };
29405     } catch (...) {
29406       {
29407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29408       };
29409     }
29410   }
29411   jresult = (void *)result;
29412   return jresult;
29413 }
29414
29415
29416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29417   void * jresult ;
29418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29419   Dali::Actor *arg2 = 0 ;
29420   Dali::Actor *result = 0 ;
29421
29422   arg1 = (Dali::Actor *)jarg1;
29423   arg2 = (Dali::Actor *)jarg2;
29424   if (!arg2) {
29425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29426     return 0;
29427   }
29428   {
29429     try {
29430       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29431     } catch (std::out_of_range& e) {
29432       {
29433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (std::exception& e) {
29436       {
29437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29438       };
29439     } catch (...) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29442       };
29443     }
29444   }
29445   jresult = (void *)result;
29446   return jresult;
29447 }
29448
29449
29450 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29451   char * jresult ;
29452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29453   std::string *result = 0 ;
29454
29455   arg1 = (Dali::Actor *)jarg1;
29456   {
29457     try {
29458       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29459     } catch (std::out_of_range& e) {
29460       {
29461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29462       };
29463     } catch (std::exception& e) {
29464       {
29465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29466       };
29467     } catch (...) {
29468       {
29469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29470       };
29471     }
29472   }
29473   jresult = SWIG_csharp_string_callback(result->c_str());
29474   return jresult;
29475 }
29476
29477
29478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29480   std::string *arg2 = 0 ;
29481
29482   arg1 = (Dali::Actor *)jarg1;
29483   if (!jarg2) {
29484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29485     return ;
29486   }
29487   std::string arg2_str(jarg2);
29488   arg2 = &arg2_str;
29489   {
29490     try {
29491       (arg1)->SetName((std::string const &)*arg2);
29492     } catch (std::out_of_range& e) {
29493       {
29494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29495       };
29496     } catch (std::exception& e) {
29497       {
29498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29503       };
29504     }
29505   }
29506
29507   //argout typemap for const std::string&
29508
29509 }
29510
29511
29512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29513   unsigned int jresult ;
29514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29515   unsigned int result;
29516
29517   arg1 = (Dali::Actor *)jarg1;
29518   {
29519     try {
29520       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29521     } catch (std::out_of_range& e) {
29522       {
29523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29524       };
29525     } catch (std::exception& e) {
29526       {
29527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29528       };
29529     } catch (...) {
29530       {
29531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29532       };
29533     }
29534   }
29535   jresult = result;
29536   return jresult;
29537 }
29538
29539
29540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29541   unsigned int jresult ;
29542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29543   bool result;
29544
29545   arg1 = (Dali::Actor *)jarg1;
29546   {
29547     try {
29548       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29549     } catch (std::out_of_range& e) {
29550       {
29551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29552       };
29553     } catch (std::exception& e) {
29554       {
29555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29556       };
29557     } catch (...) {
29558       {
29559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29560       };
29561     }
29562   }
29563   jresult = result;
29564   return jresult;
29565 }
29566
29567
29568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29569   unsigned int jresult ;
29570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29571   bool result;
29572
29573   arg1 = (Dali::Actor *)jarg1;
29574   {
29575     try {
29576       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29577     } catch (std::out_of_range& e) {
29578       {
29579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29580       };
29581     } catch (std::exception& e) {
29582       {
29583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29584       };
29585     } catch (...) {
29586       {
29587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29588       };
29589     }
29590   }
29591   jresult = result;
29592   return jresult;
29593 }
29594
29595
29596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29597   unsigned int jresult ;
29598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29599   bool result;
29600
29601   arg1 = (Dali::Actor *)jarg1;
29602   {
29603     try {
29604       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29605     } catch (std::out_of_range& e) {
29606       {
29607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29608       };
29609     } catch (std::exception& e) {
29610       {
29611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29612       };
29613     } catch (...) {
29614       {
29615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29616       };
29617     }
29618   }
29619   jresult = result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29625   void * jresult ;
29626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29627   Dali::Layer result;
29628
29629   arg1 = (Dali::Actor *)jarg1;
29630   {
29631     try {
29632       result = (arg1)->GetLayer();
29633     } catch (std::out_of_range& e) {
29634       {
29635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (std::exception& e) {
29638       {
29639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (...) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29644       };
29645     }
29646   }
29647   jresult = new Dali::Layer((const Dali::Layer &)result);
29648   return jresult;
29649 }
29650
29651
29652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29654   Dali::Actor arg2 ;
29655   Dali::Actor *argp2 ;
29656
29657   arg1 = (Dali::Actor *)jarg1;
29658   argp2 = (Dali::Actor *)jarg2;
29659   if (!argp2) {
29660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29661     return ;
29662   }
29663   arg2 = *argp2;
29664   {
29665     try {
29666       (arg1)->Add(arg2);
29667     } catch (std::out_of_range& e) {
29668       {
29669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29670       };
29671     } catch (std::exception& e) {
29672       {
29673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29674       };
29675     } catch (...) {
29676       {
29677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29678       };
29679     }
29680   }
29681 }
29682
29683
29684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29686   Dali::Actor arg2 ;
29687   Dali::Actor *argp2 ;
29688
29689   arg1 = (Dali::Actor *)jarg1;
29690   argp2 = (Dali::Actor *)jarg2;
29691   if (!argp2) {
29692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29693     return ;
29694   }
29695   arg2 = *argp2;
29696   {
29697     try {
29698       (arg1)->Remove(arg2);
29699     } catch (std::out_of_range& e) {
29700       {
29701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29702       };
29703     } catch (std::exception& e) {
29704       {
29705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29706       };
29707     } catch (...) {
29708       {
29709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29710       };
29711     }
29712   }
29713 }
29714
29715
29716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29718
29719   arg1 = (Dali::Actor *)jarg1;
29720   {
29721     try {
29722       (arg1)->Unparent();
29723     } catch (std::out_of_range& e) {
29724       {
29725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29726       };
29727     } catch (std::exception& e) {
29728       {
29729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29730       };
29731     } catch (...) {
29732       {
29733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29734       };
29735     }
29736   }
29737 }
29738
29739
29740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29741   unsigned int jresult ;
29742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29743   unsigned int result;
29744
29745   arg1 = (Dali::Actor *)jarg1;
29746   {
29747     try {
29748       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29749     } catch (std::out_of_range& e) {
29750       {
29751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29752       };
29753     } catch (std::exception& e) {
29754       {
29755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29756       };
29757     } catch (...) {
29758       {
29759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29760       };
29761     }
29762   }
29763   jresult = result;
29764   return jresult;
29765 }
29766
29767
29768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29769   void * jresult ;
29770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29771   unsigned int arg2 ;
29772   Dali::Actor result;
29773
29774   arg1 = (Dali::Actor *)jarg1;
29775   arg2 = (unsigned int)jarg2;
29776   {
29777     try {
29778       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29779     } catch (std::out_of_range& e) {
29780       {
29781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29782       };
29783     } catch (std::exception& e) {
29784       {
29785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29786       };
29787     } catch (...) {
29788       {
29789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29790       };
29791     }
29792   }
29793   jresult = new Dali::Actor((const Dali::Actor &)result);
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29799   void * jresult ;
29800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29801   std::string *arg2 = 0 ;
29802   Dali::Actor result;
29803
29804   arg1 = (Dali::Actor *)jarg1;
29805   if (!jarg2) {
29806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29807     return 0;
29808   }
29809   std::string arg2_str(jarg2);
29810   arg2 = &arg2_str;
29811   {
29812     try {
29813       result = (arg1)->FindChildByName((std::string const &)*arg2);
29814     } catch (std::out_of_range& e) {
29815       {
29816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29817       };
29818     } catch (std::exception& e) {
29819       {
29820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29821       };
29822     } catch (...) {
29823       {
29824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29825       };
29826     }
29827   }
29828   jresult = new Dali::Actor((const Dali::Actor &)result);
29829
29830   //argout typemap for const std::string&
29831
29832   return jresult;
29833 }
29834
29835
29836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29837   void * jresult ;
29838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29839   unsigned int arg2 ;
29840   Dali::Actor result;
29841
29842   arg1 = (Dali::Actor *)jarg1;
29843   arg2 = (unsigned int)jarg2;
29844   {
29845     try {
29846       result = (arg1)->FindChildById(arg2);
29847     } catch (std::out_of_range& e) {
29848       {
29849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (std::exception& e) {
29852       {
29853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861   jresult = new Dali::Actor((const Dali::Actor &)result);
29862   return jresult;
29863 }
29864
29865
29866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29867   void * jresult ;
29868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29869   Dali::Actor result;
29870
29871   arg1 = (Dali::Actor *)jarg1;
29872   {
29873     try {
29874       result = ((Dali::Actor const *)arg1)->GetParent();
29875     } catch (std::out_of_range& e) {
29876       {
29877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (std::exception& e) {
29880       {
29881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (...) {
29884       {
29885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29886       };
29887     }
29888   }
29889   jresult = new Dali::Actor((const Dali::Actor &)result);
29890   return jresult;
29891 }
29892
29893
29894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29896   Dali::Vector3 *arg2 = 0 ;
29897
29898   arg1 = (Dali::Actor *)jarg1;
29899   arg2 = (Dali::Vector3 *)jarg2;
29900   if (!arg2) {
29901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29902     return ;
29903   }
29904   {
29905     try {
29906       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29907     } catch (std::out_of_range& e) {
29908       {
29909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29910       };
29911     } catch (std::exception& e) {
29912       {
29913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29914       };
29915     } catch (...) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29918       };
29919     }
29920   }
29921 }
29922
29923
29924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29925   void * jresult ;
29926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29927   Dali::Vector3 result;
29928
29929   arg1 = (Dali::Actor *)jarg1;
29930   {
29931     try {
29932       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29933     } catch (std::out_of_range& e) {
29934       {
29935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29936       };
29937     } catch (std::exception& e) {
29938       {
29939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29940       };
29941     } catch (...) {
29942       {
29943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29944       };
29945     }
29946   }
29947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29948   return jresult;
29949 }
29950
29951
29952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29954   Dali::Vector3 *arg2 = 0 ;
29955
29956   arg1 = (Dali::Actor *)jarg1;
29957   arg2 = (Dali::Vector3 *)jarg2;
29958   if (!arg2) {
29959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29960     return ;
29961   }
29962   {
29963     try {
29964       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29965     } catch (std::out_of_range& e) {
29966       {
29967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29968       };
29969     } catch (std::exception& e) {
29970       {
29971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29976       };
29977     }
29978   }
29979 }
29980
29981
29982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29983   void * jresult ;
29984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29985   Dali::Vector3 result;
29986
29987   arg1 = (Dali::Actor *)jarg1;
29988   {
29989     try {
29990       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29991     } catch (std::out_of_range& e) {
29992       {
29993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29994       };
29995     } catch (std::exception& e) {
29996       {
29997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29998       };
29999     } catch (...) {
30000       {
30001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30002       };
30003     }
30004   }
30005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30012   float arg2 ;
30013   float arg3 ;
30014
30015   arg1 = (Dali::Actor *)jarg1;
30016   arg2 = (float)jarg2;
30017   arg3 = (float)jarg3;
30018   {
30019     try {
30020       (arg1)->SetSize(arg2,arg3);
30021     } catch (std::out_of_range& e) {
30022       {
30023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30024       };
30025     } catch (std::exception& e) {
30026       {
30027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30028       };
30029     } catch (...) {
30030       {
30031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30032       };
30033     }
30034   }
30035 }
30036
30037
30038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30040   float arg2 ;
30041   float arg3 ;
30042   float arg4 ;
30043
30044   arg1 = (Dali::Actor *)jarg1;
30045   arg2 = (float)jarg2;
30046   arg3 = (float)jarg3;
30047   arg4 = (float)jarg4;
30048   {
30049     try {
30050       (arg1)->SetSize(arg2,arg3,arg4);
30051     } catch (std::out_of_range& e) {
30052       {
30053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30054       };
30055     } catch (std::exception& e) {
30056       {
30057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30058       };
30059     } catch (...) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30062       };
30063     }
30064   }
30065 }
30066
30067
30068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30070   Dali::Vector2 *arg2 = 0 ;
30071
30072   arg1 = (Dali::Actor *)jarg1;
30073   arg2 = (Dali::Vector2 *)jarg2;
30074   if (!arg2) {
30075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30076     return ;
30077   }
30078   {
30079     try {
30080       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30081     } catch (std::out_of_range& e) {
30082       {
30083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30084       };
30085     } catch (std::exception& e) {
30086       {
30087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30088       };
30089     } catch (...) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30092       };
30093     }
30094   }
30095 }
30096
30097
30098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30100   Dali::Vector3 *arg2 = 0 ;
30101
30102   arg1 = (Dali::Actor *)jarg1;
30103   arg2 = (Dali::Vector3 *)jarg2;
30104   if (!arg2) {
30105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30106     return ;
30107   }
30108   {
30109     try {
30110       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30111     } catch (std::out_of_range& e) {
30112       {
30113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30114       };
30115     } catch (std::exception& e) {
30116       {
30117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30118       };
30119     } catch (...) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30122       };
30123     }
30124   }
30125 }
30126
30127
30128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30129   void * jresult ;
30130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30131   Dali::Vector3 result;
30132
30133   arg1 = (Dali::Actor *)jarg1;
30134   {
30135     try {
30136       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30137     } catch (std::out_of_range& e) {
30138       {
30139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30140       };
30141     } catch (std::exception& e) {
30142       {
30143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (...) {
30146       {
30147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30148       };
30149     }
30150   }
30151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30152   return jresult;
30153 }
30154
30155
30156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30157   void * jresult ;
30158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30159   Dali::Vector3 result;
30160
30161   arg1 = (Dali::Actor *)jarg1;
30162   {
30163     try {
30164       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30165     } catch (std::out_of_range& e) {
30166       {
30167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30168       };
30169     } catch (std::exception& e) {
30170       {
30171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30172       };
30173     } catch (...) {
30174       {
30175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30176       };
30177     }
30178   }
30179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30180   return jresult;
30181 }
30182
30183
30184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30185   void * jresult ;
30186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30187   Dali::Vector3 result;
30188
30189   arg1 = (Dali::Actor *)jarg1;
30190   {
30191     try {
30192       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30193     } catch (std::out_of_range& e) {
30194       {
30195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30196       };
30197     } catch (std::exception& e) {
30198       {
30199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30200       };
30201     } catch (...) {
30202       {
30203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30204       };
30205     }
30206   }
30207   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30208   return jresult;
30209 }
30210
30211
30212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30214   float arg2 ;
30215   float arg3 ;
30216
30217   arg1 = (Dali::Actor *)jarg1;
30218   arg2 = (float)jarg2;
30219   arg3 = (float)jarg3;
30220   {
30221     try {
30222       (arg1)->SetPosition(arg2,arg3);
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30230       };
30231     } catch (...) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30234       };
30235     }
30236   }
30237 }
30238
30239
30240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30242   float arg2 ;
30243   float arg3 ;
30244   float arg4 ;
30245
30246   arg1 = (Dali::Actor *)jarg1;
30247   arg2 = (float)jarg2;
30248   arg3 = (float)jarg3;
30249   arg4 = (float)jarg4;
30250   {
30251     try {
30252       (arg1)->SetPosition(arg2,arg3,arg4);
30253     } catch (std::out_of_range& e) {
30254       {
30255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30256       };
30257     } catch (std::exception& e) {
30258       {
30259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30260       };
30261     } catch (...) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30264       };
30265     }
30266   }
30267 }
30268
30269
30270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30272   Dali::Vector3 *arg2 = 0 ;
30273
30274   arg1 = (Dali::Actor *)jarg1;
30275   arg2 = (Dali::Vector3 *)jarg2;
30276   if (!arg2) {
30277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30278     return ;
30279   }
30280   {
30281     try {
30282       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30283     } catch (std::out_of_range& e) {
30284       {
30285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30286       };
30287     } catch (std::exception& e) {
30288       {
30289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30290       };
30291     } catch (...) {
30292       {
30293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30294       };
30295     }
30296   }
30297 }
30298
30299
30300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30302   float arg2 ;
30303
30304   arg1 = (Dali::Actor *)jarg1;
30305   arg2 = (float)jarg2;
30306   {
30307     try {
30308       (arg1)->SetX(arg2);
30309     } catch (std::out_of_range& e) {
30310       {
30311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30312       };
30313     } catch (std::exception& e) {
30314       {
30315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30316       };
30317     } catch (...) {
30318       {
30319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30320       };
30321     }
30322   }
30323 }
30324
30325
30326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30328   float arg2 ;
30329
30330   arg1 = (Dali::Actor *)jarg1;
30331   arg2 = (float)jarg2;
30332   {
30333     try {
30334       (arg1)->SetY(arg2);
30335     } catch (std::out_of_range& e) {
30336       {
30337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30338       };
30339     } catch (std::exception& e) {
30340       {
30341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30342       };
30343     } catch (...) {
30344       {
30345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30346       };
30347     }
30348   }
30349 }
30350
30351
30352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30354   float arg2 ;
30355
30356   arg1 = (Dali::Actor *)jarg1;
30357   arg2 = (float)jarg2;
30358   {
30359     try {
30360       (arg1)->SetZ(arg2);
30361     } catch (std::out_of_range& e) {
30362       {
30363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30364       };
30365     } catch (std::exception& e) {
30366       {
30367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30368       };
30369     } catch (...) {
30370       {
30371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30372       };
30373     }
30374   }
30375 }
30376
30377
30378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30380   Dali::Vector3 *arg2 = 0 ;
30381
30382   arg1 = (Dali::Actor *)jarg1;
30383   arg2 = (Dali::Vector3 *)jarg2;
30384   if (!arg2) {
30385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30386     return ;
30387   }
30388   {
30389     try {
30390       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30391     } catch (std::out_of_range& e) {
30392       {
30393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30394       };
30395     } catch (std::exception& e) {
30396       {
30397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30398       };
30399     } catch (...) {
30400       {
30401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30402       };
30403     }
30404   }
30405 }
30406
30407
30408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30409   void * jresult ;
30410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30411   Dali::Vector3 result;
30412
30413   arg1 = (Dali::Actor *)jarg1;
30414   {
30415     try {
30416       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30417     } catch (std::out_of_range& e) {
30418       {
30419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30420       };
30421     } catch (std::exception& e) {
30422       {
30423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30424       };
30425     } catch (...) {
30426       {
30427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30428       };
30429     }
30430   }
30431   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30437   void * jresult ;
30438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30439   Dali::Vector3 result;
30440
30441   arg1 = (Dali::Actor *)jarg1;
30442   {
30443     try {
30444       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30445     } catch (std::out_of_range& e) {
30446       {
30447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30448       };
30449     } catch (std::exception& e) {
30450       {
30451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30452       };
30453     } catch (...) {
30454       {
30455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30456       };
30457     }
30458   }
30459   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30460   return jresult;
30461 }
30462
30463
30464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30466   bool arg2 ;
30467
30468   arg1 = (Dali::Actor *)jarg1;
30469   arg2 = jarg2 ? true : false;
30470   {
30471     try {
30472       (arg1)->SetInheritPosition(arg2);
30473     } catch (std::out_of_range& e) {
30474       {
30475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (std::exception& e) {
30478       {
30479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30480       };
30481     } catch (...) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30484       };
30485     }
30486   }
30487 }
30488
30489
30490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30491   int jresult ;
30492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30493   Dali::PositionInheritanceMode result;
30494
30495   arg1 = (Dali::Actor *)jarg1;
30496   {
30497     try {
30498       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30499     } catch (std::out_of_range& e) {
30500       {
30501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30502       };
30503     } catch (std::exception& e) {
30504       {
30505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30506       };
30507     } catch (...) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30510       };
30511     }
30512   }
30513   jresult = (int)result;
30514   return jresult;
30515 }
30516
30517
30518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30519   unsigned int jresult ;
30520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30521   bool result;
30522
30523   arg1 = (Dali::Actor *)jarg1;
30524   {
30525     try {
30526       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541   jresult = result;
30542   return jresult;
30543 }
30544
30545
30546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30548   Dali::Degree *arg2 = 0 ;
30549   Dali::Vector3 *arg3 = 0 ;
30550
30551   arg1 = (Dali::Actor *)jarg1;
30552   arg2 = (Dali::Degree *)jarg2;
30553   if (!arg2) {
30554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30555     return ;
30556   }
30557   arg3 = (Dali::Vector3 *)jarg3;
30558   if (!arg3) {
30559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30560     return ;
30561   }
30562   {
30563     try {
30564       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30572       };
30573     } catch (...) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30576       };
30577     }
30578   }
30579 }
30580
30581
30582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30584   Dali::Radian *arg2 = 0 ;
30585   Dali::Vector3 *arg3 = 0 ;
30586
30587   arg1 = (Dali::Actor *)jarg1;
30588   arg2 = (Dali::Radian *)jarg2;
30589   if (!arg2) {
30590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30591     return ;
30592   }
30593   arg3 = (Dali::Vector3 *)jarg3;
30594   if (!arg3) {
30595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30596     return ;
30597   }
30598   {
30599     try {
30600       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30601     } catch (std::out_of_range& e) {
30602       {
30603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30604       };
30605     } catch (std::exception& e) {
30606       {
30607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30608       };
30609     } catch (...) {
30610       {
30611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30612       };
30613     }
30614   }
30615 }
30616
30617
30618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30620   Dali::Quaternion *arg2 = 0 ;
30621
30622   arg1 = (Dali::Actor *)jarg1;
30623   arg2 = (Dali::Quaternion *)jarg2;
30624   if (!arg2) {
30625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30626     return ;
30627   }
30628   {
30629     try {
30630       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30631     } catch (std::out_of_range& e) {
30632       {
30633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30634       };
30635     } catch (std::exception& e) {
30636       {
30637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30638       };
30639     } catch (...) {
30640       {
30641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30642       };
30643     }
30644   }
30645 }
30646
30647
30648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30650   Dali::Degree *arg2 = 0 ;
30651   Dali::Vector3 *arg3 = 0 ;
30652
30653   arg1 = (Dali::Actor *)jarg1;
30654   arg2 = (Dali::Degree *)jarg2;
30655   if (!arg2) {
30656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30657     return ;
30658   }
30659   arg3 = (Dali::Vector3 *)jarg3;
30660   if (!arg3) {
30661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30662     return ;
30663   }
30664   {
30665     try {
30666       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30667     } catch (std::out_of_range& e) {
30668       {
30669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30670       };
30671     } catch (std::exception& e) {
30672       {
30673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30674       };
30675     } catch (...) {
30676       {
30677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30678       };
30679     }
30680   }
30681 }
30682
30683
30684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30686   Dali::Radian *arg2 = 0 ;
30687   Dali::Vector3 *arg3 = 0 ;
30688
30689   arg1 = (Dali::Actor *)jarg1;
30690   arg2 = (Dali::Radian *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30693     return ;
30694   }
30695   arg3 = (Dali::Vector3 *)jarg3;
30696   if (!arg3) {
30697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30698     return ;
30699   }
30700   {
30701     try {
30702       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30710       };
30711     } catch (...) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30714       };
30715     }
30716   }
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30722   Dali::Quaternion *arg2 = 0 ;
30723
30724   arg1 = (Dali::Actor *)jarg1;
30725   arg2 = (Dali::Quaternion *)jarg2;
30726   if (!arg2) {
30727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30728     return ;
30729   }
30730   {
30731     try {
30732       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30733     } catch (std::out_of_range& e) {
30734       {
30735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (std::exception& e) {
30738       {
30739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747 }
30748
30749
30750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30751   void * jresult ;
30752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30753   Dali::Quaternion result;
30754
30755   arg1 = (Dali::Actor *)jarg1;
30756   {
30757     try {
30758       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30759     } catch (std::out_of_range& e) {
30760       {
30761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30762       };
30763     } catch (std::exception& e) {
30764       {
30765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30766       };
30767     } catch (...) {
30768       {
30769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30770       };
30771     }
30772   }
30773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30774   return jresult;
30775 }
30776
30777
30778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30780   bool arg2 ;
30781
30782   arg1 = (Dali::Actor *)jarg1;
30783   arg2 = jarg2 ? true : false;
30784   {
30785     try {
30786       (arg1)->SetInheritOrientation(arg2);
30787     } catch (std::out_of_range& e) {
30788       {
30789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30790       };
30791     } catch (std::exception& e) {
30792       {
30793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30794       };
30795     } catch (...) {
30796       {
30797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30798       };
30799     }
30800   }
30801 }
30802
30803
30804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30805   unsigned int jresult ;
30806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30807   bool result;
30808
30809   arg1 = (Dali::Actor *)jarg1;
30810   {
30811     try {
30812       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30813     } catch (std::out_of_range& e) {
30814       {
30815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30816       };
30817     } catch (std::exception& e) {
30818       {
30819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30820       };
30821     } catch (...) {
30822       {
30823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30824       };
30825     }
30826   }
30827   jresult = result;
30828   return jresult;
30829 }
30830
30831
30832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30833   void * jresult ;
30834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30835   Dali::Quaternion result;
30836
30837   arg1 = (Dali::Actor *)jarg1;
30838   {
30839     try {
30840       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30841     } catch (std::out_of_range& e) {
30842       {
30843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30844       };
30845     } catch (std::exception& e) {
30846       {
30847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30848       };
30849     } catch (...) {
30850       {
30851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30852       };
30853     }
30854   }
30855   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30856   return jresult;
30857 }
30858
30859
30860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30862   float arg2 ;
30863
30864   arg1 = (Dali::Actor *)jarg1;
30865   arg2 = (float)jarg2;
30866   {
30867     try {
30868       (arg1)->SetScale(arg2);
30869     } catch (std::out_of_range& e) {
30870       {
30871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30872       };
30873     } catch (std::exception& e) {
30874       {
30875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30876       };
30877     } catch (...) {
30878       {
30879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30880       };
30881     }
30882   }
30883 }
30884
30885
30886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30888   float arg2 ;
30889   float arg3 ;
30890   float arg4 ;
30891
30892   arg1 = (Dali::Actor *)jarg1;
30893   arg2 = (float)jarg2;
30894   arg3 = (float)jarg3;
30895   arg4 = (float)jarg4;
30896   {
30897     try {
30898       (arg1)->SetScale(arg2,arg3,arg4);
30899     } catch (std::out_of_range& e) {
30900       {
30901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30902       };
30903     } catch (std::exception& e) {
30904       {
30905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30906       };
30907     } catch (...) {
30908       {
30909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30910       };
30911     }
30912   }
30913 }
30914
30915
30916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30918   Dali::Vector3 *arg2 = 0 ;
30919
30920   arg1 = (Dali::Actor *)jarg1;
30921   arg2 = (Dali::Vector3 *)jarg2;
30922   if (!arg2) {
30923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30924     return ;
30925   }
30926   {
30927     try {
30928       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30936       };
30937     } catch (...) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30940       };
30941     }
30942   }
30943 }
30944
30945
30946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30948   Dali::Vector3 *arg2 = 0 ;
30949
30950   arg1 = (Dali::Actor *)jarg1;
30951   arg2 = (Dali::Vector3 *)jarg2;
30952   if (!arg2) {
30953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30954     return ;
30955   }
30956   {
30957     try {
30958       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30959     } catch (std::out_of_range& e) {
30960       {
30961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30962       };
30963     } catch (std::exception& e) {
30964       {
30965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30966       };
30967     } catch (...) {
30968       {
30969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30970       };
30971     }
30972   }
30973 }
30974
30975
30976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30977   void * jresult ;
30978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30979   Dali::Vector3 result;
30980
30981   arg1 = (Dali::Actor *)jarg1;
30982   {
30983     try {
30984       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30985     } catch (std::out_of_range& e) {
30986       {
30987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30988       };
30989     } catch (std::exception& e) {
30990       {
30991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30992       };
30993     } catch (...) {
30994       {
30995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30996       };
30997     }
30998   }
30999   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31000   return jresult;
31001 }
31002
31003
31004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31005   void * jresult ;
31006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31007   Dali::Vector3 result;
31008
31009   arg1 = (Dali::Actor *)jarg1;
31010   {
31011     try {
31012       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31013     } catch (std::out_of_range& e) {
31014       {
31015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31016       };
31017     } catch (std::exception& e) {
31018       {
31019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31020       };
31021     } catch (...) {
31022       {
31023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31024       };
31025     }
31026   }
31027   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31028   return jresult;
31029 }
31030
31031
31032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31034   bool arg2 ;
31035
31036   arg1 = (Dali::Actor *)jarg1;
31037   arg2 = jarg2 ? true : false;
31038   {
31039     try {
31040       (arg1)->SetInheritScale(arg2);
31041     } catch (std::out_of_range& e) {
31042       {
31043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31044       };
31045     } catch (std::exception& e) {
31046       {
31047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31048       };
31049     } catch (...) {
31050       {
31051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31052       };
31053     }
31054   }
31055 }
31056
31057
31058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31059   unsigned int jresult ;
31060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31061   bool result;
31062
31063   arg1 = (Dali::Actor *)jarg1;
31064   {
31065     try {
31066       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31067     } catch (std::out_of_range& e) {
31068       {
31069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (std::exception& e) {
31072       {
31073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (...) {
31076       {
31077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31078       };
31079     }
31080   }
31081   jresult = result;
31082   return jresult;
31083 }
31084
31085
31086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31087   void * jresult ;
31088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31089   Dali::Matrix result;
31090
31091   arg1 = (Dali::Actor *)jarg1;
31092   {
31093     try {
31094       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31095     } catch (std::out_of_range& e) {
31096       {
31097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31098       };
31099     } catch (std::exception& e) {
31100       {
31101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31102       };
31103     } catch (...) {
31104       {
31105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31106       };
31107     }
31108   }
31109   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31110   return jresult;
31111 }
31112
31113
31114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31116   bool arg2 ;
31117
31118   arg1 = (Dali::Actor *)jarg1;
31119   arg2 = jarg2 ? true : false;
31120   {
31121     try {
31122       (arg1)->SetVisible(arg2);
31123     } catch (std::out_of_range& e) {
31124       {
31125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31126       };
31127     } catch (std::exception& e) {
31128       {
31129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31130       };
31131     } catch (...) {
31132       {
31133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31134       };
31135     }
31136   }
31137 }
31138
31139
31140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31141   unsigned int jresult ;
31142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31143   bool result;
31144
31145   arg1 = (Dali::Actor *)jarg1;
31146   {
31147     try {
31148       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31149     } catch (std::out_of_range& e) {
31150       {
31151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31152       };
31153     } catch (std::exception& e) {
31154       {
31155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31156       };
31157     } catch (...) {
31158       {
31159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31160       };
31161     }
31162   }
31163   jresult = result;
31164   return jresult;
31165 }
31166
31167
31168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31170   float arg2 ;
31171
31172   arg1 = (Dali::Actor *)jarg1;
31173   arg2 = (float)jarg2;
31174   {
31175     try {
31176       (arg1)->SetOpacity(arg2);
31177     } catch (std::out_of_range& e) {
31178       {
31179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31180       };
31181     } catch (std::exception& e) {
31182       {
31183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31188       };
31189     }
31190   }
31191 }
31192
31193
31194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31195   float jresult ;
31196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31197   float result;
31198
31199   arg1 = (Dali::Actor *)jarg1;
31200   {
31201     try {
31202       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31203     } catch (std::out_of_range& e) {
31204       {
31205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31206       };
31207     } catch (std::exception& e) {
31208       {
31209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (...) {
31212       {
31213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31214       };
31215     }
31216   }
31217   jresult = result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31224   Dali::Vector4 *arg2 = 0 ;
31225
31226   arg1 = (Dali::Actor *)jarg1;
31227   arg2 = (Dali::Vector4 *)jarg2;
31228   if (!arg2) {
31229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31230     return ;
31231   }
31232   {
31233     try {
31234       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31246       };
31247     }
31248   }
31249 }
31250
31251
31252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31253   void * jresult ;
31254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31255   Dali::Vector4 result;
31256
31257   arg1 = (Dali::Actor *)jarg1;
31258   {
31259     try {
31260       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31261     } catch (std::out_of_range& e) {
31262       {
31263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31264       };
31265     } catch (std::exception& e) {
31266       {
31267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31268       };
31269     } catch (...) {
31270       {
31271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31272       };
31273     }
31274   }
31275   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31276   return jresult;
31277 }
31278
31279
31280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31282   Dali::ColorMode arg2 ;
31283
31284   arg1 = (Dali::Actor *)jarg1;
31285   arg2 = (Dali::ColorMode)jarg2;
31286   {
31287     try {
31288       (arg1)->SetColorMode(arg2);
31289     } catch (std::out_of_range& e) {
31290       {
31291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31292       };
31293     } catch (std::exception& e) {
31294       {
31295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31296       };
31297     } catch (...) {
31298       {
31299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31300       };
31301     }
31302   }
31303 }
31304
31305
31306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31307   int jresult ;
31308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31309   Dali::ColorMode result;
31310
31311   arg1 = (Dali::Actor *)jarg1;
31312   {
31313     try {
31314       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31315     } catch (std::out_of_range& e) {
31316       {
31317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31318       };
31319     } catch (std::exception& e) {
31320       {
31321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31322       };
31323     } catch (...) {
31324       {
31325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31326       };
31327     }
31328   }
31329   jresult = (int)result;
31330   return jresult;
31331 }
31332
31333
31334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31335   void * jresult ;
31336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31337   Dali::Vector4 result;
31338
31339   arg1 = (Dali::Actor *)jarg1;
31340   {
31341     try {
31342       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31343     } catch (std::out_of_range& e) {
31344       {
31345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31346       };
31347     } catch (std::exception& e) {
31348       {
31349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31350       };
31351     } catch (...) {
31352       {
31353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31354       };
31355     }
31356   }
31357   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31358   return jresult;
31359 }
31360
31361
31362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31364   Dali::DrawMode::Type arg2 ;
31365
31366   arg1 = (Dali::Actor *)jarg1;
31367   arg2 = (Dali::DrawMode::Type)jarg2;
31368   {
31369     try {
31370       (arg1)->SetDrawMode(arg2);
31371     } catch (std::out_of_range& e) {
31372       {
31373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31374       };
31375     } catch (std::exception& e) {
31376       {
31377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31378       };
31379     } catch (...) {
31380       {
31381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31382       };
31383     }
31384   }
31385 }
31386
31387
31388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31389   int jresult ;
31390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31391   Dali::DrawMode::Type result;
31392
31393   arg1 = (Dali::Actor *)jarg1;
31394   {
31395     try {
31396       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31397     } catch (std::out_of_range& e) {
31398       {
31399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31400       };
31401     } catch (std::exception& e) {
31402       {
31403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31404       };
31405     } catch (...) {
31406       {
31407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31408       };
31409     }
31410   }
31411   jresult = (int)result;
31412   return jresult;
31413 }
31414
31415
31416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31418   bool arg2 ;
31419
31420   arg1 = (Dali::Actor *)jarg1;
31421   arg2 = jarg2 ? true : false;
31422   {
31423     try {
31424       (arg1)->SetSensitive(arg2);
31425     } catch (std::out_of_range& e) {
31426       {
31427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31428       };
31429     } catch (std::exception& e) {
31430       {
31431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31432       };
31433     } catch (...) {
31434       {
31435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31436       };
31437     }
31438   }
31439 }
31440
31441
31442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31443   unsigned int jresult ;
31444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31445   bool result;
31446
31447   arg1 = (Dali::Actor *)jarg1;
31448   {
31449     try {
31450       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31451     } catch (std::out_of_range& e) {
31452       {
31453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31454       };
31455     } catch (std::exception& e) {
31456       {
31457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31458       };
31459     } catch (...) {
31460       {
31461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31462       };
31463     }
31464   }
31465   jresult = result;
31466   return jresult;
31467 }
31468
31469
31470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31471   unsigned int jresult ;
31472   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31473   float *arg2 = 0 ;
31474   float *arg3 = 0 ;
31475   float arg4 ;
31476   float arg5 ;
31477   bool result;
31478
31479   arg1 = (Dali::Actor *)jarg1;
31480   arg2 = (float *)jarg2;
31481   arg3 = (float *)jarg3;
31482   arg4 = (float)jarg4;
31483   arg5 = (float)jarg5;
31484   {
31485     try {
31486       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31487     } catch (std::out_of_range& e) {
31488       {
31489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31490       };
31491     } catch (std::exception& e) {
31492       {
31493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31494       };
31495     } catch (...) {
31496       {
31497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31498       };
31499     }
31500   }
31501   jresult = result;
31502   return jresult;
31503 }
31504
31505
31506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31508   bool arg2 ;
31509
31510   arg1 = (Dali::Actor *)jarg1;
31511   arg2 = jarg2 ? true : false;
31512   {
31513     try {
31514       (arg1)->SetLeaveRequired(arg2);
31515     } catch (std::out_of_range& e) {
31516       {
31517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31518       };
31519     } catch (std::exception& e) {
31520       {
31521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31522       };
31523     } catch (...) {
31524       {
31525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31526       };
31527     }
31528   }
31529 }
31530
31531
31532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31533   unsigned int jresult ;
31534   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31535   bool result;
31536
31537   arg1 = (Dali::Actor *)jarg1;
31538   {
31539     try {
31540       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31541     } catch (std::out_of_range& e) {
31542       {
31543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31544       };
31545     } catch (std::exception& e) {
31546       {
31547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31548       };
31549     } catch (...) {
31550       {
31551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31552       };
31553     }
31554   }
31555   jresult = result;
31556   return jresult;
31557 }
31558
31559
31560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31562   bool arg2 ;
31563
31564   arg1 = (Dali::Actor *)jarg1;
31565   arg2 = jarg2 ? true : false;
31566   {
31567     try {
31568       (arg1)->SetKeyboardFocusable(arg2);
31569     } catch (std::out_of_range& e) {
31570       {
31571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31572       };
31573     } catch (std::exception& e) {
31574       {
31575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31576       };
31577     } catch (...) {
31578       {
31579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31580       };
31581     }
31582   }
31583 }
31584
31585
31586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31587   unsigned int jresult ;
31588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31589   bool result;
31590
31591   arg1 = (Dali::Actor *)jarg1;
31592   {
31593     try {
31594       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31595     } catch (std::out_of_range& e) {
31596       {
31597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31598       };
31599     } catch (std::exception& e) {
31600       {
31601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31602       };
31603     } catch (...) {
31604       {
31605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31606       };
31607     }
31608   }
31609   jresult = result;
31610   return jresult;
31611 }
31612
31613
31614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31616   Dali::ResizePolicy::Type arg2 ;
31617   Dali::Dimension::Type arg3 ;
31618
31619   arg1 = (Dali::Actor *)jarg1;
31620   arg2 = (Dali::ResizePolicy::Type)jarg2;
31621   arg3 = (Dali::Dimension::Type)jarg3;
31622   {
31623     try {
31624       (arg1)->SetResizePolicy(arg2,arg3);
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31632       };
31633     } catch (...) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31636       };
31637     }
31638   }
31639 }
31640
31641
31642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31643   int jresult ;
31644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31645   Dali::Dimension::Type arg2 ;
31646   Dali::ResizePolicy::Type result;
31647
31648   arg1 = (Dali::Actor *)jarg1;
31649   arg2 = (Dali::Dimension::Type)jarg2;
31650   {
31651     try {
31652       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31653     } catch (std::out_of_range& e) {
31654       {
31655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (std::exception& e) {
31658       {
31659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31664       };
31665     }
31666   }
31667   jresult = (int)result;
31668   return jresult;
31669 }
31670
31671
31672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31674   Dali::SizeScalePolicy::Type arg2 ;
31675
31676   arg1 = (Dali::Actor *)jarg1;
31677   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31678   {
31679     try {
31680       (arg1)->SetSizeScalePolicy(arg2);
31681     } catch (std::out_of_range& e) {
31682       {
31683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31684       };
31685     } catch (std::exception& e) {
31686       {
31687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31688       };
31689     } catch (...) {
31690       {
31691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31692       };
31693     }
31694   }
31695 }
31696
31697
31698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31699   int jresult ;
31700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31701   Dali::SizeScalePolicy::Type result;
31702
31703   arg1 = (Dali::Actor *)jarg1;
31704   {
31705     try {
31706       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31707     } catch (std::out_of_range& e) {
31708       {
31709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31710       };
31711     } catch (std::exception& e) {
31712       {
31713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31714       };
31715     } catch (...) {
31716       {
31717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31718       };
31719     }
31720   }
31721   jresult = (int)result;
31722   return jresult;
31723 }
31724
31725
31726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31728   Dali::Vector3 *arg2 = 0 ;
31729
31730   arg1 = (Dali::Actor *)jarg1;
31731   arg2 = (Dali::Vector3 *)jarg2;
31732   if (!arg2) {
31733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31734     return ;
31735   }
31736   {
31737     try {
31738       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31746       };
31747     } catch (...) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31750       };
31751     }
31752   }
31753 }
31754
31755
31756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31757   void * jresult ;
31758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31759   Dali::Vector3 result;
31760
31761   arg1 = (Dali::Actor *)jarg1;
31762   {
31763     try {
31764       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31765     } catch (std::out_of_range& e) {
31766       {
31767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31768       };
31769     } catch (std::exception& e) {
31770       {
31771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31772       };
31773     } catch (...) {
31774       {
31775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31776       };
31777     }
31778   }
31779   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31780   return jresult;
31781 }
31782
31783
31784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31785   float jresult ;
31786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31787   float arg2 ;
31788   float result;
31789
31790   arg1 = (Dali::Actor *)jarg1;
31791   arg2 = (float)jarg2;
31792   {
31793     try {
31794       result = (float)(arg1)->GetHeightForWidth(arg2);
31795     } catch (std::out_of_range& e) {
31796       {
31797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31798       };
31799     } catch (std::exception& e) {
31800       {
31801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (...) {
31804       {
31805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31806       };
31807     }
31808   }
31809   jresult = result;
31810   return jresult;
31811 }
31812
31813
31814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31815   float jresult ;
31816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31817   float arg2 ;
31818   float result;
31819
31820   arg1 = (Dali::Actor *)jarg1;
31821   arg2 = (float)jarg2;
31822   {
31823     try {
31824       result = (float)(arg1)->GetWidthForHeight(arg2);
31825     } catch (std::out_of_range& e) {
31826       {
31827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31828       };
31829     } catch (std::exception& e) {
31830       {
31831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31832       };
31833     } catch (...) {
31834       {
31835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31836       };
31837     }
31838   }
31839   jresult = result;
31840   return jresult;
31841 }
31842
31843
31844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31845   float jresult ;
31846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31847   Dali::Dimension::Type arg2 ;
31848   float result;
31849
31850   arg1 = (Dali::Actor *)jarg1;
31851   arg2 = (Dali::Dimension::Type)jarg2;
31852   {
31853     try {
31854       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31855     } catch (std::out_of_range& e) {
31856       {
31857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31858       };
31859     } catch (std::exception& e) {
31860       {
31861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31862       };
31863     } catch (...) {
31864       {
31865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31866       };
31867     }
31868   }
31869   jresult = result;
31870   return jresult;
31871 }
31872
31873
31874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31876   Dali::Padding *arg2 = 0 ;
31877
31878   arg1 = (Dali::Actor *)jarg1;
31879   arg2 = (Dali::Padding *)jarg2;
31880   if (!arg2) {
31881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31882     return ;
31883   }
31884   {
31885     try {
31886       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31887     } catch (std::out_of_range& e) {
31888       {
31889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31890       };
31891     } catch (std::exception& e) {
31892       {
31893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31894       };
31895     } catch (...) {
31896       {
31897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31898       };
31899     }
31900   }
31901 }
31902
31903
31904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31906   Dali::Padding *arg2 = 0 ;
31907
31908   arg1 = (Dali::Actor *)jarg1;
31909   arg2 = (Dali::Padding *)jarg2;
31910   if (!arg2) {
31911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31912     return ;
31913   }
31914   {
31915     try {
31916       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31917     } catch (std::out_of_range& e) {
31918       {
31919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31920       };
31921     } catch (std::exception& e) {
31922       {
31923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31924       };
31925     } catch (...) {
31926       {
31927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31928       };
31929     }
31930   }
31931 }
31932
31933
31934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31936   Dali::Vector2 *arg2 = 0 ;
31937
31938   arg1 = (Dali::Actor *)jarg1;
31939   arg2 = (Dali::Vector2 *)jarg2;
31940   if (!arg2) {
31941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31942     return ;
31943   }
31944   {
31945     try {
31946       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31947     } catch (std::out_of_range& e) {
31948       {
31949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31950       };
31951     } catch (std::exception& e) {
31952       {
31953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31954       };
31955     } catch (...) {
31956       {
31957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31958       };
31959     }
31960   }
31961 }
31962
31963
31964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31965   void * jresult ;
31966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31967   Dali::Vector2 result;
31968
31969   arg1 = (Dali::Actor *)jarg1;
31970   {
31971     try {
31972       result = (arg1)->GetMinimumSize();
31973     } catch (std::out_of_range& e) {
31974       {
31975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31976       };
31977     } catch (std::exception& e) {
31978       {
31979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (...) {
31982       {
31983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31984       };
31985     }
31986   }
31987   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31988   return jresult;
31989 }
31990
31991
31992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31994   Dali::Vector2 *arg2 = 0 ;
31995
31996   arg1 = (Dali::Actor *)jarg1;
31997   arg2 = (Dali::Vector2 *)jarg2;
31998   if (!arg2) {
31999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32000     return ;
32001   }
32002   {
32003     try {
32004       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32005     } catch (std::out_of_range& e) {
32006       {
32007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32008       };
32009     } catch (std::exception& e) {
32010       {
32011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (...) {
32014       {
32015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32016       };
32017     }
32018   }
32019 }
32020
32021
32022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32023   void * jresult ;
32024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32025   Dali::Vector2 result;
32026
32027   arg1 = (Dali::Actor *)jarg1;
32028   {
32029     try {
32030       result = (arg1)->GetMaximumSize();
32031     } catch (std::out_of_range& e) {
32032       {
32033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32034       };
32035     } catch (std::exception& e) {
32036       {
32037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32038       };
32039     } catch (...) {
32040       {
32041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32042       };
32043     }
32044   }
32045   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32046   return jresult;
32047 }
32048
32049
32050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32051   int jresult ;
32052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32053   int result;
32054
32055   arg1 = (Dali::Actor *)jarg1;
32056   {
32057     try {
32058       result = (int)(arg1)->GetHierarchyDepth();
32059     } catch (std::out_of_range& e) {
32060       {
32061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32062       };
32063     } catch (std::exception& e) {
32064       {
32065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32066       };
32067     } catch (...) {
32068       {
32069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32070       };
32071     }
32072   }
32073   jresult = result;
32074   return jresult;
32075 }
32076
32077
32078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32079   unsigned int jresult ;
32080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32081   Dali::Renderer *arg2 = 0 ;
32082   unsigned int result;
32083
32084   arg1 = (Dali::Actor *)jarg1;
32085   arg2 = (Dali::Renderer *)jarg2;
32086   if (!arg2) {
32087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32088     return 0;
32089   }
32090   {
32091     try {
32092       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32093     } catch (std::out_of_range& e) {
32094       {
32095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32096       };
32097     } catch (std::exception& e) {
32098       {
32099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32100       };
32101     } catch (...) {
32102       {
32103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32104       };
32105     }
32106   }
32107   jresult = result;
32108   return jresult;
32109 }
32110
32111
32112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32113   unsigned int jresult ;
32114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32115   unsigned int result;
32116
32117   arg1 = (Dali::Actor *)jarg1;
32118   {
32119     try {
32120       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32121     } catch (std::out_of_range& e) {
32122       {
32123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32124       };
32125     } catch (std::exception& e) {
32126       {
32127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32128       };
32129     } catch (...) {
32130       {
32131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32132       };
32133     }
32134   }
32135   jresult = result;
32136   return jresult;
32137 }
32138
32139
32140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32141   void * jresult ;
32142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32143   unsigned int arg2 ;
32144   Dali::Renderer result;
32145
32146   arg1 = (Dali::Actor *)jarg1;
32147   arg2 = (unsigned int)jarg2;
32148   {
32149     try {
32150       result = (arg1)->GetRendererAt(arg2);
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (...) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32162       };
32163     }
32164   }
32165   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32166   return jresult;
32167 }
32168
32169
32170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32172   Dali::Renderer *arg2 = 0 ;
32173
32174   arg1 = (Dali::Actor *)jarg1;
32175   arg2 = (Dali::Renderer *)jarg2;
32176   if (!arg2) {
32177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32178     return ;
32179   }
32180   {
32181     try {
32182       (arg1)->RemoveRenderer(*arg2);
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (...) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32194       };
32195     }
32196   }
32197 }
32198
32199
32200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32202   unsigned int arg2 ;
32203
32204   arg1 = (Dali::Actor *)jarg1;
32205   arg2 = (unsigned int)jarg2;
32206   {
32207     try {
32208       (arg1)->RemoveRenderer(arg2);
32209     } catch (std::out_of_range& e) {
32210       {
32211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32212       };
32213     } catch (std::exception& e) {
32214       {
32215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32216       };
32217     } catch (...) {
32218       {
32219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32220       };
32221     }
32222   }
32223 }
32224
32225
32226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32227   void * jresult ;
32228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32229   Dali::Actor::TouchSignalType *result = 0 ;
32230
32231   arg1 = (Dali::Actor *)jarg1;
32232   {
32233     try {
32234       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32235     } catch (std::out_of_range& e) {
32236       {
32237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32238       };
32239     } catch (std::exception& e) {
32240       {
32241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32242       };
32243     } catch (...) {
32244       {
32245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32246       };
32247     }
32248   }
32249   jresult = (void *)result;
32250   return jresult;
32251 }
32252
32253
32254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32255   void * jresult ;
32256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32257   Dali::Actor::TouchDataSignalType *result = 0 ;
32258
32259   arg1 = (Dali::Actor *)jarg1;
32260   {
32261     try {
32262       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32263     } catch (std::out_of_range& e) {
32264       {
32265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32266       };
32267     } catch (std::exception& e) {
32268       {
32269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32270       };
32271     } catch (...) {
32272       {
32273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32274       };
32275     }
32276   }
32277   jresult = (void *)result;
32278   return jresult;
32279 }
32280
32281
32282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32283   void * jresult ;
32284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32285   Dali::Actor::HoverSignalType *result = 0 ;
32286
32287   arg1 = (Dali::Actor *)jarg1;
32288   {
32289     try {
32290       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32291     } catch (std::out_of_range& e) {
32292       {
32293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32294       };
32295     } catch (std::exception& e) {
32296       {
32297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32298       };
32299     } catch (...) {
32300       {
32301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32302       };
32303     }
32304   }
32305   jresult = (void *)result;
32306   return jresult;
32307 }
32308
32309
32310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32311   void * jresult ;
32312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32313   Dali::Actor::WheelEventSignalType *result = 0 ;
32314
32315   arg1 = (Dali::Actor *)jarg1;
32316   {
32317     try {
32318       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32319     } catch (std::out_of_range& e) {
32320       {
32321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (std::exception& e) {
32324       {
32325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32326       };
32327     } catch (...) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32330       };
32331     }
32332   }
32333   jresult = (void *)result;
32334   return jresult;
32335 }
32336
32337
32338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32339   void * jresult ;
32340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32341   Dali::Actor::OnStageSignalType *result = 0 ;
32342
32343   arg1 = (Dali::Actor *)jarg1;
32344   {
32345     try {
32346       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32347     } catch (std::out_of_range& e) {
32348       {
32349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32350       };
32351     } catch (std::exception& e) {
32352       {
32353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32354       };
32355     } catch (...) {
32356       {
32357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32358       };
32359     }
32360   }
32361   jresult = (void *)result;
32362   return jresult;
32363 }
32364
32365
32366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32367   void * jresult ;
32368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32369   Dali::Actor::OffStageSignalType *result = 0 ;
32370
32371   arg1 = (Dali::Actor *)jarg1;
32372   {
32373     try {
32374       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32375     } catch (std::out_of_range& e) {
32376       {
32377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (std::exception& e) {
32380       {
32381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389   jresult = (void *)result;
32390   return jresult;
32391 }
32392
32393
32394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32395   void * jresult ;
32396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32397   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32398
32399   arg1 = (Dali::Actor *)jarg1;
32400   {
32401     try {
32402       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32403     } catch (std::out_of_range& e) {
32404       {
32405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32406       };
32407     } catch (std::exception& e) {
32408       {
32409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32410       };
32411     } catch (...) {
32412       {
32413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32414       };
32415     }
32416   }
32417   jresult = (void *)result;
32418   return jresult;
32419 }
32420
32421
32422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32423   Dali::Actor *arg1 = 0 ;
32424
32425   arg1 = (Dali::Actor *)jarg1;
32426   if (!arg1) {
32427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32428     return ;
32429   }
32430   {
32431     try {
32432       Dali::UnparentAndReset(*arg1);
32433     } catch (std::out_of_range& e) {
32434       {
32435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32436       };
32437     } catch (std::exception& e) {
32438       {
32439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32440       };
32441     } catch (...) {
32442       {
32443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32444       };
32445     }
32446   }
32447 }
32448
32449
32450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32451   int jresult ;
32452   int result;
32453
32454   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32455   jresult = (int)result;
32456   return jresult;
32457 }
32458
32459
32460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32461   int jresult ;
32462   int result;
32463
32464   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32465   jresult = (int)result;
32466   return jresult;
32467 }
32468
32469
32470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32471   int jresult ;
32472   int result;
32473
32474   result = (int)Dali::Layer::Property::BEHAVIOR;
32475   jresult = (int)result;
32476   return jresult;
32477 }
32478
32479
32480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32481   void * jresult ;
32482   Dali::Layer::Property *result = 0 ;
32483
32484   {
32485     try {
32486       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32487     } catch (std::out_of_range& e) {
32488       {
32489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (std::exception& e) {
32492       {
32493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32494       };
32495     } catch (...) {
32496       {
32497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32498       };
32499     }
32500   }
32501   jresult = (void *)result;
32502   return jresult;
32503 }
32504
32505
32506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32507   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32508
32509   arg1 = (Dali::Layer::Property *)jarg1;
32510   {
32511     try {
32512       delete arg1;
32513     } catch (std::out_of_range& e) {
32514       {
32515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32516       };
32517     } catch (std::exception& e) {
32518       {
32519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32524       };
32525     }
32526   }
32527 }
32528
32529
32530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32531   void * jresult ;
32532   Dali::Layer *result = 0 ;
32533
32534   {
32535     try {
32536       result = (Dali::Layer *)new Dali::Layer();
32537     } catch (std::out_of_range& e) {
32538       {
32539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32540       };
32541     } catch (std::exception& e) {
32542       {
32543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32544       };
32545     } catch (...) {
32546       {
32547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32548       };
32549     }
32550   }
32551   jresult = (void *)result;
32552   return jresult;
32553 }
32554
32555
32556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32557   void * jresult ;
32558   Dali::Layer result;
32559
32560   {
32561     try {
32562       result = Dali::Layer::New();
32563     } catch (std::out_of_range& e) {
32564       {
32565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32566       };
32567     } catch (std::exception& e) {
32568       {
32569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32570       };
32571     } catch (...) {
32572       {
32573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32574       };
32575     }
32576   }
32577   jresult = new Dali::Layer((const Dali::Layer &)result);
32578   return jresult;
32579 }
32580
32581
32582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32583   void * jresult ;
32584   Dali::BaseHandle arg1 ;
32585   Dali::BaseHandle *argp1 ;
32586   Dali::Layer result;
32587
32588   argp1 = (Dali::BaseHandle *)jarg1;
32589   if (!argp1) {
32590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32591     return 0;
32592   }
32593   arg1 = *argp1;
32594   {
32595     try {
32596       result = Dali::Layer::DownCast(arg1);
32597     } catch (std::out_of_range& e) {
32598       {
32599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32600       };
32601     } catch (std::exception& e) {
32602       {
32603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32604       };
32605     } catch (...) {
32606       {
32607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32608       };
32609     }
32610   }
32611   jresult = new Dali::Layer((const Dali::Layer &)result);
32612   return jresult;
32613 }
32614
32615
32616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32617   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32618
32619   arg1 = (Dali::Layer *)jarg1;
32620   {
32621     try {
32622       delete arg1;
32623     } catch (std::out_of_range& e) {
32624       {
32625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32626       };
32627     } catch (std::exception& e) {
32628       {
32629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (...) {
32632       {
32633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32634       };
32635     }
32636   }
32637 }
32638
32639
32640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32641   void * jresult ;
32642   Dali::Layer *arg1 = 0 ;
32643   Dali::Layer *result = 0 ;
32644
32645   arg1 = (Dali::Layer *)jarg1;
32646   if (!arg1) {
32647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32648     return 0;
32649   }
32650   {
32651     try {
32652       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32653     } catch (std::out_of_range& e) {
32654       {
32655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32656       };
32657     } catch (std::exception& e) {
32658       {
32659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32660       };
32661     } catch (...) {
32662       {
32663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32664       };
32665     }
32666   }
32667   jresult = (void *)result;
32668   return jresult;
32669 }
32670
32671
32672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32673   void * jresult ;
32674   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32675   Dali::Layer *arg2 = 0 ;
32676   Dali::Layer *result = 0 ;
32677
32678   arg1 = (Dali::Layer *)jarg1;
32679   arg2 = (Dali::Layer *)jarg2;
32680   if (!arg2) {
32681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32682     return 0;
32683   }
32684   {
32685     try {
32686       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32687     } catch (std::out_of_range& e) {
32688       {
32689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32690       };
32691     } catch (std::exception& e) {
32692       {
32693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32698       };
32699     }
32700   }
32701   jresult = (void *)result;
32702   return jresult;
32703 }
32704
32705
32706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32707   unsigned int jresult ;
32708   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32709   unsigned int result;
32710
32711   arg1 = (Dali::Layer *)jarg1;
32712   {
32713     try {
32714       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32715     } catch (std::out_of_range& e) {
32716       {
32717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32718       };
32719     } catch (std::exception& e) {
32720       {
32721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32722       };
32723     } catch (...) {
32724       {
32725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32726       };
32727     }
32728   }
32729   jresult = result;
32730   return jresult;
32731 }
32732
32733
32734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32736
32737   arg1 = (Dali::Layer *)jarg1;
32738   {
32739     try {
32740       (arg1)->Raise();
32741     } catch (std::out_of_range& e) {
32742       {
32743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32744       };
32745     } catch (std::exception& e) {
32746       {
32747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32748       };
32749     } catch (...) {
32750       {
32751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32752       };
32753     }
32754   }
32755 }
32756
32757
32758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32759   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32760
32761   arg1 = (Dali::Layer *)jarg1;
32762   {
32763     try {
32764       (arg1)->Lower();
32765     } catch (std::out_of_range& e) {
32766       {
32767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32768       };
32769     } catch (std::exception& e) {
32770       {
32771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32772       };
32773     } catch (...) {
32774       {
32775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32776       };
32777     }
32778   }
32779 }
32780
32781
32782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32784   Dali::Layer arg2 ;
32785   Dali::Layer *argp2 ;
32786
32787   arg1 = (Dali::Layer *)jarg1;
32788   argp2 = (Dali::Layer *)jarg2;
32789   if (!argp2) {
32790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32791     return ;
32792   }
32793   arg2 = *argp2;
32794   {
32795     try {
32796       (arg1)->RaiseAbove(arg2);
32797     } catch (std::out_of_range& e) {
32798       {
32799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32800       };
32801     } catch (std::exception& e) {
32802       {
32803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32804       };
32805     } catch (...) {
32806       {
32807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32808       };
32809     }
32810   }
32811 }
32812
32813
32814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32816   Dali::Layer arg2 ;
32817   Dali::Layer *argp2 ;
32818
32819   arg1 = (Dali::Layer *)jarg1;
32820   argp2 = (Dali::Layer *)jarg2;
32821   if (!argp2) {
32822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32823     return ;
32824   }
32825   arg2 = *argp2;
32826   {
32827     try {
32828       (arg1)->LowerBelow(arg2);
32829     } catch (std::out_of_range& e) {
32830       {
32831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32832       };
32833     } catch (std::exception& e) {
32834       {
32835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32836       };
32837     } catch (...) {
32838       {
32839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32840       };
32841     }
32842   }
32843 }
32844
32845
32846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32848
32849   arg1 = (Dali::Layer *)jarg1;
32850   {
32851     try {
32852       (arg1)->RaiseToTop();
32853     } catch (std::out_of_range& e) {
32854       {
32855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32856       };
32857     } catch (std::exception& e) {
32858       {
32859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32860       };
32861     } catch (...) {
32862       {
32863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32864       };
32865     }
32866   }
32867 }
32868
32869
32870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32872
32873   arg1 = (Dali::Layer *)jarg1;
32874   {
32875     try {
32876       (arg1)->LowerToBottom();
32877     } catch (std::out_of_range& e) {
32878       {
32879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32880       };
32881     } catch (std::exception& e) {
32882       {
32883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32884       };
32885     } catch (...) {
32886       {
32887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32888       };
32889     }
32890   }
32891 }
32892
32893
32894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32895   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32896   Dali::Layer arg2 ;
32897   Dali::Layer *argp2 ;
32898
32899   arg1 = (Dali::Layer *)jarg1;
32900   argp2 = (Dali::Layer *)jarg2;
32901   if (!argp2) {
32902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32903     return ;
32904   }
32905   arg2 = *argp2;
32906   {
32907     try {
32908       (arg1)->MoveAbove(arg2);
32909     } catch (std::out_of_range& e) {
32910       {
32911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32912       };
32913     } catch (std::exception& e) {
32914       {
32915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32916       };
32917     } catch (...) {
32918       {
32919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32920       };
32921     }
32922   }
32923 }
32924
32925
32926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32927   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32928   Dali::Layer arg2 ;
32929   Dali::Layer *argp2 ;
32930
32931   arg1 = (Dali::Layer *)jarg1;
32932   argp2 = (Dali::Layer *)jarg2;
32933   if (!argp2) {
32934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32935     return ;
32936   }
32937   arg2 = *argp2;
32938   {
32939     try {
32940       (arg1)->MoveBelow(arg2);
32941     } catch (std::out_of_range& e) {
32942       {
32943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32944       };
32945     } catch (std::exception& e) {
32946       {
32947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32948       };
32949     } catch (...) {
32950       {
32951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32952       };
32953     }
32954   }
32955 }
32956
32957
32958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32959   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32960   Dali::Layer::Behavior arg2 ;
32961
32962   arg1 = (Dali::Layer *)jarg1;
32963   arg2 = (Dali::Layer::Behavior)jarg2;
32964   {
32965     try {
32966       (arg1)->SetBehavior(arg2);
32967     } catch (std::out_of_range& e) {
32968       {
32969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32970       };
32971     } catch (std::exception& e) {
32972       {
32973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32974       };
32975     } catch (...) {
32976       {
32977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32978       };
32979     }
32980   }
32981 }
32982
32983
32984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32985   int jresult ;
32986   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32987   Dali::Layer::Behavior result;
32988
32989   arg1 = (Dali::Layer *)jarg1;
32990   {
32991     try {
32992       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32993     } catch (std::out_of_range& e) {
32994       {
32995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32996       };
32997     } catch (std::exception& e) {
32998       {
32999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33000       };
33001     } catch (...) {
33002       {
33003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33004       };
33005     }
33006   }
33007   jresult = (int)result;
33008   return jresult;
33009 }
33010
33011
33012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33013   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33014   bool arg2 ;
33015
33016   arg1 = (Dali::Layer *)jarg1;
33017   arg2 = jarg2 ? true : false;
33018   {
33019     try {
33020       (arg1)->SetClipping(arg2);
33021     } catch (std::out_of_range& e) {
33022       {
33023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33024       };
33025     } catch (std::exception& e) {
33026       {
33027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33028       };
33029     } catch (...) {
33030       {
33031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33032       };
33033     }
33034   }
33035 }
33036
33037
33038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33039   unsigned int jresult ;
33040   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33041   bool result;
33042
33043   arg1 = (Dali::Layer *)jarg1;
33044   {
33045     try {
33046       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33047     } catch (std::out_of_range& e) {
33048       {
33049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33050       };
33051     } catch (std::exception& e) {
33052       {
33053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33054       };
33055     } catch (...) {
33056       {
33057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33058       };
33059     }
33060   }
33061   jresult = result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33067   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33068   int arg2 ;
33069   int arg3 ;
33070   int arg4 ;
33071   int arg5 ;
33072
33073   arg1 = (Dali::Layer *)jarg1;
33074   arg2 = (int)jarg2;
33075   arg3 = (int)jarg3;
33076   arg4 = (int)jarg4;
33077   arg5 = (int)jarg5;
33078   {
33079     try {
33080       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33081     } catch (std::out_of_range& e) {
33082       {
33083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33084       };
33085     } catch (std::exception& e) {
33086       {
33087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33088       };
33089     } catch (...) {
33090       {
33091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33092       };
33093     }
33094   }
33095 }
33096
33097
33098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33099   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33100   Dali::ClippingBox arg2 ;
33101   Dali::ClippingBox *argp2 ;
33102
33103   arg1 = (Dali::Layer *)jarg1;
33104   argp2 = (Dali::ClippingBox *)jarg2;
33105   if (!argp2) {
33106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33107     return ;
33108   }
33109   arg2 = *argp2;
33110   {
33111     try {
33112       (arg1)->SetClippingBox(arg2);
33113     } catch (std::out_of_range& e) {
33114       {
33115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33116       };
33117     } catch (std::exception& e) {
33118       {
33119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33120       };
33121     } catch (...) {
33122       {
33123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33124       };
33125     }
33126   }
33127 }
33128
33129
33130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33131   void * jresult ;
33132   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33133   Dali::ClippingBox result;
33134
33135   arg1 = (Dali::Layer *)jarg1;
33136   {
33137     try {
33138       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33139     } catch (std::out_of_range& e) {
33140       {
33141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33142       };
33143     } catch (std::exception& e) {
33144       {
33145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33146       };
33147     } catch (...) {
33148       {
33149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33150       };
33151     }
33152   }
33153   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33159   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33160   bool arg2 ;
33161
33162   arg1 = (Dali::Layer *)jarg1;
33163   arg2 = jarg2 ? true : false;
33164   {
33165     try {
33166       (arg1)->SetDepthTestDisabled(arg2);
33167     } catch (std::out_of_range& e) {
33168       {
33169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33170       };
33171     } catch (std::exception& e) {
33172       {
33173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33174       };
33175     } catch (...) {
33176       {
33177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33178       };
33179     }
33180   }
33181 }
33182
33183
33184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33185   unsigned int jresult ;
33186   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33187   bool result;
33188
33189   arg1 = (Dali::Layer *)jarg1;
33190   {
33191     try {
33192       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33193     } catch (std::out_of_range& e) {
33194       {
33195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33196       };
33197     } catch (std::exception& e) {
33198       {
33199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33200       };
33201     } catch (...) {
33202       {
33203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33204       };
33205     }
33206   }
33207   jresult = result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33213   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33214   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33215
33216   arg1 = (Dali::Layer *)jarg1;
33217   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33218   {
33219     try {
33220       (arg1)->SetSortFunction(arg2);
33221     } catch (std::out_of_range& e) {
33222       {
33223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33224       };
33225     } catch (std::exception& e) {
33226       {
33227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33228       };
33229     } catch (...) {
33230       {
33231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33232       };
33233     }
33234   }
33235 }
33236
33237
33238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33239   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33240   bool arg2 ;
33241
33242   arg1 = (Dali::Layer *)jarg1;
33243   arg2 = jarg2 ? true : false;
33244   {
33245     try {
33246       (arg1)->SetTouchConsumed(arg2);
33247     } catch (std::out_of_range& e) {
33248       {
33249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33250       };
33251     } catch (std::exception& e) {
33252       {
33253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33254       };
33255     } catch (...) {
33256       {
33257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33258       };
33259     }
33260   }
33261 }
33262
33263
33264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33265   unsigned int jresult ;
33266   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33267   bool result;
33268
33269   arg1 = (Dali::Layer *)jarg1;
33270   {
33271     try {
33272       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33273     } catch (std::out_of_range& e) {
33274       {
33275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33276       };
33277     } catch (std::exception& e) {
33278       {
33279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33280       };
33281     } catch (...) {
33282       {
33283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33284       };
33285     }
33286   }
33287   jresult = result;
33288   return jresult;
33289 }
33290
33291
33292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33293   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33294   bool arg2 ;
33295
33296   arg1 = (Dali::Layer *)jarg1;
33297   arg2 = jarg2 ? true : false;
33298   {
33299     try {
33300       (arg1)->SetHoverConsumed(arg2);
33301     } catch (std::out_of_range& e) {
33302       {
33303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33304       };
33305     } catch (std::exception& e) {
33306       {
33307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33308       };
33309     } catch (...) {
33310       {
33311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33312       };
33313     }
33314   }
33315 }
33316
33317
33318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33319   unsigned int jresult ;
33320   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33321   bool result;
33322
33323   arg1 = (Dali::Layer *)jarg1;
33324   {
33325     try {
33326       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33327     } catch (std::out_of_range& e) {
33328       {
33329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33330       };
33331     } catch (std::exception& e) {
33332       {
33333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33334       };
33335     } catch (...) {
33336       {
33337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33338       };
33339     }
33340   }
33341   jresult = result;
33342   return jresult;
33343 }
33344
33345
33346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33347   void * jresult ;
33348   Dali::Vector4 *result = 0 ;
33349
33350   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33351   jresult = (void *)result;
33352   return jresult;
33353 }
33354
33355
33356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33357   void * jresult ;
33358   Dali::Vector4 *result = 0 ;
33359
33360   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33361   jresult = (void *)result;
33362   return jresult;
33363 }
33364
33365
33366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33367   void * jresult ;
33368   Dali::Stage *result = 0 ;
33369
33370   {
33371     try {
33372       result = (Dali::Stage *)new Dali::Stage();
33373     } catch (std::out_of_range& e) {
33374       {
33375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (std::exception& e) {
33378       {
33379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387   jresult = (void *)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33393   void * jresult ;
33394   Dali::Stage result;
33395
33396   {
33397     try {
33398       result = Dali::Stage::GetCurrent();
33399     } catch (std::out_of_range& e) {
33400       {
33401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33402       };
33403     } catch (std::exception& e) {
33404       {
33405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33406       };
33407     } catch (...) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33410       };
33411     }
33412   }
33413   jresult = new Dali::Stage((const Dali::Stage &)result);
33414   return jresult;
33415 }
33416
33417
33418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33419   unsigned int jresult ;
33420   bool result;
33421
33422   {
33423     try {
33424       result = (bool)Dali::Stage::IsInstalled();
33425     } catch (std::out_of_range& e) {
33426       {
33427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33428       };
33429     } catch (std::exception& e) {
33430       {
33431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33432       };
33433     } catch (...) {
33434       {
33435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33436       };
33437     }
33438   }
33439   jresult = result;
33440   return jresult;
33441 }
33442
33443
33444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33445   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33446
33447   arg1 = (Dali::Stage *)jarg1;
33448   {
33449     try {
33450       delete arg1;
33451     } catch (std::out_of_range& e) {
33452       {
33453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33454       };
33455     } catch (std::exception& e) {
33456       {
33457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33458       };
33459     } catch (...) {
33460       {
33461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33462       };
33463     }
33464   }
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33469   void * jresult ;
33470   Dali::Stage *arg1 = 0 ;
33471   Dali::Stage *result = 0 ;
33472
33473   arg1 = (Dali::Stage *)jarg1;
33474   if (!arg1) {
33475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33476     return 0;
33477   }
33478   {
33479     try {
33480       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33481     } catch (std::out_of_range& e) {
33482       {
33483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (std::exception& e) {
33486       {
33487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33488       };
33489     } catch (...) {
33490       {
33491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33492       };
33493     }
33494   }
33495   jresult = (void *)result;
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33501   void * jresult ;
33502   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33503   Dali::Stage *arg2 = 0 ;
33504   Dali::Stage *result = 0 ;
33505
33506   arg1 = (Dali::Stage *)jarg1;
33507   arg2 = (Dali::Stage *)jarg2;
33508   if (!arg2) {
33509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33510     return 0;
33511   }
33512   {
33513     try {
33514       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33515     } catch (std::out_of_range& e) {
33516       {
33517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33518       };
33519     } catch (std::exception& e) {
33520       {
33521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33522       };
33523     } catch (...) {
33524       {
33525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33526       };
33527     }
33528   }
33529   jresult = (void *)result;
33530   return jresult;
33531 }
33532
33533
33534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33535   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33536   Dali::Actor *arg2 = 0 ;
33537
33538   arg1 = (Dali::Stage *)jarg1;
33539   arg2 = (Dali::Actor *)jarg2;
33540   if (!arg2) {
33541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33542     return ;
33543   }
33544   {
33545     try {
33546       (arg1)->Add(*arg2);
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (...) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33558       };
33559     }
33560   }
33561 }
33562
33563
33564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33566   Dali::Actor *arg2 = 0 ;
33567
33568   arg1 = (Dali::Stage *)jarg1;
33569   arg2 = (Dali::Actor *)jarg2;
33570   if (!arg2) {
33571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33572     return ;
33573   }
33574   {
33575     try {
33576       (arg1)->Remove(*arg2);
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33588       };
33589     }
33590   }
33591 }
33592
33593
33594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33595   void * jresult ;
33596   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33597   Dali::Vector2 result;
33598
33599   arg1 = (Dali::Stage *)jarg1;
33600   {
33601     try {
33602       result = ((Dali::Stage const *)arg1)->GetSize();
33603     } catch (std::out_of_range& e) {
33604       {
33605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33606       };
33607     } catch (std::exception& e) {
33608       {
33609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33610       };
33611     } catch (...) {
33612       {
33613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33614       };
33615     }
33616   }
33617   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33623   void * jresult ;
33624   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33625   Dali::RenderTaskList result;
33626
33627   arg1 = (Dali::Stage *)jarg1;
33628   {
33629     try {
33630       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33631     } catch (std::out_of_range& e) {
33632       {
33633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33634       };
33635     } catch (std::exception& e) {
33636       {
33637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (...) {
33640       {
33641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33642       };
33643     }
33644   }
33645   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33651   unsigned int jresult ;
33652   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33653   unsigned int result;
33654
33655   arg1 = (Dali::Stage *)jarg1;
33656   {
33657     try {
33658       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33659     } catch (std::out_of_range& e) {
33660       {
33661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33662       };
33663     } catch (std::exception& e) {
33664       {
33665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33666       };
33667     } catch (...) {
33668       {
33669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33670       };
33671     }
33672   }
33673   jresult = result;
33674   return jresult;
33675 }
33676
33677
33678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33679   void * jresult ;
33680   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33681   unsigned int arg2 ;
33682   Dali::Layer result;
33683
33684   arg1 = (Dali::Stage *)jarg1;
33685   arg2 = (unsigned int)jarg2;
33686   {
33687     try {
33688       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33689     } catch (std::out_of_range& e) {
33690       {
33691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33692       };
33693     } catch (std::exception& e) {
33694       {
33695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33696       };
33697     } catch (...) {
33698       {
33699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33700       };
33701     }
33702   }
33703   jresult = new Dali::Layer((const Dali::Layer &)result);
33704   return jresult;
33705 }
33706
33707
33708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33709   void * jresult ;
33710   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33711   Dali::Layer result;
33712
33713   arg1 = (Dali::Stage *)jarg1;
33714   {
33715     try {
33716       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (...) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33728       };
33729     }
33730   }
33731   jresult = new Dali::Layer((const Dali::Layer &)result);
33732   return jresult;
33733 }
33734
33735
33736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33737   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33738   Dali::Vector4 arg2 ;
33739   Dali::Vector4 *argp2 ;
33740
33741   arg1 = (Dali::Stage *)jarg1;
33742   argp2 = (Dali::Vector4 *)jarg2;
33743   if (!argp2) {
33744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33745     return ;
33746   }
33747   arg2 = *argp2;
33748   {
33749     try {
33750       (arg1)->SetBackgroundColor(arg2);
33751     } catch (std::out_of_range& e) {
33752       {
33753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33754       };
33755     } catch (std::exception& e) {
33756       {
33757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33758       };
33759     } catch (...) {
33760       {
33761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33762       };
33763     }
33764   }
33765 }
33766
33767
33768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33769   void * jresult ;
33770   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33771   Dali::Vector4 result;
33772
33773   arg1 = (Dali::Stage *)jarg1;
33774   {
33775     try {
33776       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33777     } catch (std::out_of_range& e) {
33778       {
33779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33780       };
33781     } catch (std::exception& e) {
33782       {
33783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33788       };
33789     }
33790   }
33791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33792   return jresult;
33793 }
33794
33795
33796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33797   void * jresult ;
33798   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33799   Dali::Vector2 result;
33800
33801   arg1 = (Dali::Stage *)jarg1;
33802   {
33803     try {
33804       result = ((Dali::Stage const *)arg1)->GetDpi();
33805     } catch (std::out_of_range& e) {
33806       {
33807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33808       };
33809     } catch (std::exception& e) {
33810       {
33811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33812       };
33813     } catch (...) {
33814       {
33815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33816       };
33817     }
33818   }
33819   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33820   return jresult;
33821 }
33822
33823
33824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33825   void * jresult ;
33826   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33827   Dali::ObjectRegistry result;
33828
33829   arg1 = (Dali::Stage *)jarg1;
33830   {
33831     try {
33832       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33833     } catch (std::out_of_range& e) {
33834       {
33835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33836       };
33837     } catch (std::exception& e) {
33838       {
33839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33840       };
33841     } catch (...) {
33842       {
33843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33844       };
33845     }
33846   }
33847   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33848   return jresult;
33849 }
33850
33851
33852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33853   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33854   float arg2 ;
33855
33856   arg1 = (Dali::Stage *)jarg1;
33857   arg2 = (float)jarg2;
33858   {
33859     try {
33860       (arg1)->KeepRendering(arg2);
33861     } catch (std::out_of_range& e) {
33862       {
33863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33864       };
33865     } catch (std::exception& e) {
33866       {
33867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33868       };
33869     } catch (...) {
33870       {
33871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33872       };
33873     }
33874   }
33875 }
33876
33877
33878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33879   void * jresult ;
33880   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33881   Dali::Stage::KeyEventSignalType *result = 0 ;
33882
33883   arg1 = (Dali::Stage *)jarg1;
33884   {
33885     try {
33886       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (...) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33898       };
33899     }
33900   }
33901   jresult = (void *)result;
33902   return jresult;
33903 }
33904
33905
33906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33907   void * jresult ;
33908   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33909   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33910
33911   arg1 = (Dali::Stage *)jarg1;
33912   {
33913     try {
33914       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33915     } catch (std::out_of_range& e) {
33916       {
33917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33918       };
33919     } catch (std::exception& e) {
33920       {
33921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33922       };
33923     } catch (...) {
33924       {
33925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33926       };
33927     }
33928   }
33929   jresult = (void *)result;
33930   return jresult;
33931 }
33932
33933
33934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33935   void * jresult ;
33936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33937   Dali::Stage::TouchSignalType *result = 0 ;
33938
33939   arg1 = (Dali::Stage *)jarg1;
33940   {
33941     try {
33942       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33943     } catch (std::out_of_range& e) {
33944       {
33945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33946       };
33947     } catch (std::exception& e) {
33948       {
33949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (...) {
33952       {
33953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33954       };
33955     }
33956   }
33957   jresult = (void *)result;
33958   return jresult;
33959 }
33960
33961
33962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33963   void * jresult ;
33964   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33965   Dali::Stage::WheelEventSignalType *result = 0 ;
33966
33967   arg1 = (Dali::Stage *)jarg1;
33968   {
33969     try {
33970       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33971     } catch (std::out_of_range& e) {
33972       {
33973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33974       };
33975     } catch (std::exception& e) {
33976       {
33977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33978       };
33979     } catch (...) {
33980       {
33981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33982       };
33983     }
33984   }
33985   jresult = (void *)result;
33986   return jresult;
33987 }
33988
33989
33990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33991   void * jresult ;
33992   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33993   Dali::Stage::ContextStatusSignal *result = 0 ;
33994
33995   arg1 = (Dali::Stage *)jarg1;
33996   {
33997     try {
33998       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33999     } catch (std::out_of_range& e) {
34000       {
34001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34002       };
34003     } catch (std::exception& e) {
34004       {
34005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34010       };
34011     }
34012   }
34013   jresult = (void *)result;
34014   return jresult;
34015 }
34016
34017
34018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34019   void * jresult ;
34020   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34021   Dali::Stage::ContextStatusSignal *result = 0 ;
34022
34023   arg1 = (Dali::Stage *)jarg1;
34024   {
34025     try {
34026       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34027     } catch (std::out_of_range& e) {
34028       {
34029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34030       };
34031     } catch (std::exception& e) {
34032       {
34033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34034       };
34035     } catch (...) {
34036       {
34037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34038       };
34039     }
34040   }
34041   jresult = (void *)result;
34042   return jresult;
34043 }
34044
34045
34046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34047   void * jresult ;
34048   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34049   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34050
34051   arg1 = (Dali::Stage *)jarg1;
34052   {
34053     try {
34054       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34055     } catch (std::out_of_range& e) {
34056       {
34057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34058       };
34059     } catch (std::exception& e) {
34060       {
34061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (...) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34066       };
34067     }
34068   }
34069   jresult = (void *)result;
34070   return jresult;
34071 }
34072
34073
34074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34075   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34076
34077   arg1 = (Dali::RelayoutContainer *)jarg1;
34078   {
34079     try {
34080       delete arg1;
34081     } catch (std::out_of_range& e) {
34082       {
34083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34084       };
34085     } catch (std::exception& e) {
34086       {
34087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34088       };
34089     } catch (...) {
34090       {
34091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34092       };
34093     }
34094   }
34095 }
34096
34097
34098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34099   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34100   Dali::Actor *arg2 = 0 ;
34101   Dali::Vector2 *arg3 = 0 ;
34102
34103   arg1 = (Dali::RelayoutContainer *)jarg1;
34104   arg2 = (Dali::Actor *)jarg2;
34105   if (!arg2) {
34106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34107     return ;
34108   }
34109   arg3 = (Dali::Vector2 *)jarg3;
34110   if (!arg3) {
34111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34112     return ;
34113   }
34114   {
34115     try {
34116       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34117     } catch (std::out_of_range& e) {
34118       {
34119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34120       };
34121     } catch (std::exception& e) {
34122       {
34123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34124       };
34125     } catch (...) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34128       };
34129     }
34130   }
34131 }
34132
34133
34134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34135   void * jresult ;
34136   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34137   Dali::CustomActor result;
34138
34139   arg1 = (Dali::CustomActorImpl *)jarg1;
34140   {
34141     try {
34142       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34143     } catch (std::out_of_range& e) {
34144       {
34145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34146       };
34147     } catch (std::exception& e) {
34148       {
34149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34150       };
34151     } catch (...) {
34152       {
34153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34154       };
34155     }
34156   }
34157   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34158   return jresult;
34159 }
34160
34161
34162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34164   int arg2 ;
34165
34166   arg1 = (Dali::CustomActorImpl *)jarg1;
34167   arg2 = (int)jarg2;
34168   {
34169     try {
34170       (arg1)->OnStageConnection(arg2);
34171     } catch (std::out_of_range& e) {
34172       {
34173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (std::exception& e) {
34176       {
34177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185 }
34186
34187
34188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34189   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34190
34191   arg1 = (Dali::CustomActorImpl *)jarg1;
34192   {
34193     try {
34194       (arg1)->OnStageDisconnection();
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (...) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34206       };
34207     }
34208   }
34209 }
34210
34211
34212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34213   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34214   Dali::Actor *arg2 = 0 ;
34215
34216   arg1 = (Dali::CustomActorImpl *)jarg1;
34217   arg2 = (Dali::Actor *)jarg2;
34218   if (!arg2) {
34219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34220     return ;
34221   }
34222   {
34223     try {
34224       (arg1)->OnChildAdd(*arg2);
34225     } catch (std::out_of_range& e) {
34226       {
34227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34228       };
34229     } catch (std::exception& e) {
34230       {
34231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34232       };
34233     } catch (...) {
34234       {
34235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34236       };
34237     }
34238   }
34239 }
34240
34241
34242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34243   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34244   Dali::Actor *arg2 = 0 ;
34245
34246   arg1 = (Dali::CustomActorImpl *)jarg1;
34247   arg2 = (Dali::Actor *)jarg2;
34248   if (!arg2) {
34249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34250     return ;
34251   }
34252   {
34253     try {
34254       (arg1)->OnChildRemove(*arg2);
34255     } catch (std::out_of_range& e) {
34256       {
34257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34258       };
34259     } catch (std::exception& e) {
34260       {
34261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34262       };
34263     } catch (...) {
34264       {
34265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34266       };
34267     }
34268   }
34269 }
34270
34271
34272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34273   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34274   Dali::Property::Index arg2 ;
34275   Dali::Property::Value arg3 ;
34276   Dali::Property::Value *argp3 ;
34277
34278   arg1 = (Dali::CustomActorImpl *)jarg1;
34279   arg2 = (Dali::Property::Index)jarg2;
34280   argp3 = (Dali::Property::Value *)jarg3;
34281   if (!argp3) {
34282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34283     return ;
34284   }
34285   arg3 = *argp3;
34286   {
34287     try {
34288       (arg1)->OnPropertySet(arg2,arg3);
34289     } catch (std::out_of_range& e) {
34290       {
34291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34292       };
34293     } catch (std::exception& e) {
34294       {
34295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34296       };
34297     } catch (...) {
34298       {
34299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34300       };
34301     }
34302   }
34303 }
34304
34305
34306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34307   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34308   Dali::Vector3 *arg2 = 0 ;
34309
34310   arg1 = (Dali::CustomActorImpl *)jarg1;
34311   arg2 = (Dali::Vector3 *)jarg2;
34312   if (!arg2) {
34313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34314     return ;
34315   }
34316   {
34317     try {
34318       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34319     } catch (std::out_of_range& e) {
34320       {
34321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34322       };
34323     } catch (std::exception& e) {
34324       {
34325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34326       };
34327     } catch (...) {
34328       {
34329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34330       };
34331     }
34332   }
34333 }
34334
34335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34336   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34337   Dali::Animation *arg2 = 0 ;
34338   Dali::Vector3 *arg3 = 0 ;
34339
34340   arg1 = (Dali::CustomActorImpl *)jarg1;
34341   arg2 = (Dali::Animation *)jarg2;
34342   if (!arg2) {
34343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34344     return ;
34345   }
34346   arg3 = (Dali::Vector3 *)jarg3;
34347   if (!arg3) {
34348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34349     return ;
34350   }
34351   {
34352     try {
34353       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34354     } catch (std::out_of_range& e) {
34355       {
34356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34357       };
34358     } catch (std::exception& e) {
34359       {
34360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (...) {
34363       {
34364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34365       };
34366     }
34367   }
34368 }
34369
34370
34371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34372   unsigned int jresult ;
34373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34374   Dali::TouchEvent *arg2 = 0 ;
34375   bool result;
34376
34377   arg1 = (Dali::CustomActorImpl *)jarg1;
34378   arg2 = (Dali::TouchEvent *)jarg2;
34379   if (!arg2) {
34380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34381     return 0;
34382   }
34383   {
34384     try {
34385       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34386     } catch (std::out_of_range& e) {
34387       {
34388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34389       };
34390     } catch (std::exception& e) {
34391       {
34392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34393       };
34394     } catch (...) {
34395       {
34396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34397       };
34398     }
34399   }
34400   jresult = result;
34401   return jresult;
34402 }
34403
34404
34405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34406   unsigned int jresult ;
34407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34408   Dali::HoverEvent *arg2 = 0 ;
34409   bool result;
34410
34411   arg1 = (Dali::CustomActorImpl *)jarg1;
34412   arg2 = (Dali::HoverEvent *)jarg2;
34413   if (!arg2) {
34414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34415     return 0;
34416   }
34417   {
34418     try {
34419       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34420     } catch (std::out_of_range& e) {
34421       {
34422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34423       };
34424     } catch (std::exception& e) {
34425       {
34426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34427       };
34428     } catch (...) {
34429       {
34430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34431       };
34432     }
34433   }
34434   jresult = result;
34435   return jresult;
34436 }
34437
34438
34439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34440   unsigned int jresult ;
34441   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34442   Dali::KeyEvent *arg2 = 0 ;
34443   bool result;
34444
34445   arg1 = (Dali::CustomActorImpl *)jarg1;
34446   arg2 = (Dali::KeyEvent *)jarg2;
34447   if (!arg2) {
34448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34449     return 0;
34450   }
34451   {
34452     try {
34453       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34454     } catch (std::out_of_range& e) {
34455       {
34456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34457       };
34458     } catch (std::exception& e) {
34459       {
34460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34461       };
34462     } catch (...) {
34463       {
34464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34465       };
34466     }
34467   }
34468   jresult = result;
34469   return jresult;
34470 }
34471
34472
34473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34474   unsigned int jresult ;
34475   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34476   Dali::WheelEvent *arg2 = 0 ;
34477   bool result;
34478
34479   arg1 = (Dali::CustomActorImpl *)jarg1;
34480   arg2 = (Dali::WheelEvent *)jarg2;
34481   if (!arg2) {
34482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34483     return 0;
34484   }
34485   {
34486     try {
34487       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34488     } catch (std::out_of_range& e) {
34489       {
34490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34491       };
34492     } catch (std::exception& e) {
34493       {
34494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34495       };
34496     } catch (...) {
34497       {
34498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34499       };
34500     }
34501   }
34502   jresult = result;
34503   return jresult;
34504 }
34505
34506
34507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::Vector2 *arg2 = 0 ;
34510   Dali::RelayoutContainer *arg3 = 0 ;
34511
34512   arg1 = (Dali::CustomActorImpl *)jarg1;
34513   arg2 = (Dali::Vector2 *)jarg2;
34514   if (!arg2) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34516     return ;
34517   }
34518   arg3 = (Dali::RelayoutContainer *)jarg3;
34519   if (!arg3) {
34520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34521     return ;
34522   }
34523   {
34524     try {
34525       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34526     } catch (std::out_of_range& e) {
34527       {
34528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34529       };
34530     } catch (std::exception& e) {
34531       {
34532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34533       };
34534     } catch (...) {
34535       {
34536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34537       };
34538     }
34539   }
34540 }
34541
34542
34543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34544   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34545   Dali::ResizePolicy::Type arg2 ;
34546   Dali::Dimension::Type arg3 ;
34547
34548   arg1 = (Dali::CustomActorImpl *)jarg1;
34549   arg2 = (Dali::ResizePolicy::Type)jarg2;
34550   arg3 = (Dali::Dimension::Type)jarg3;
34551   {
34552     try {
34553       (arg1)->OnSetResizePolicy(arg2,arg3);
34554     } catch (std::out_of_range& e) {
34555       {
34556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34557       };
34558     } catch (std::exception& e) {
34559       {
34560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34561       };
34562     } catch (...) {
34563       {
34564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34565       };
34566     }
34567   }
34568 }
34569
34570
34571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34572   void * jresult ;
34573   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34574   Dali::Vector3 result;
34575
34576   arg1 = (Dali::CustomActorImpl *)jarg1;
34577   {
34578     try {
34579       result = (arg1)->GetNaturalSize();
34580     } catch (std::out_of_range& e) {
34581       {
34582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34583       };
34584     } catch (std::exception& e) {
34585       {
34586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34587       };
34588     } catch (...) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34591       };
34592     }
34593   }
34594   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34595   return jresult;
34596 }
34597
34598
34599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34600   float jresult ;
34601   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34602   Dali::Actor *arg2 = 0 ;
34603   Dali::Dimension::Type arg3 ;
34604   float result;
34605
34606   arg1 = (Dali::CustomActorImpl *)jarg1;
34607   arg2 = (Dali::Actor *)jarg2;
34608   if (!arg2) {
34609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34610     return 0;
34611   }
34612   arg3 = (Dali::Dimension::Type)jarg3;
34613   {
34614     try {
34615       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34616     } catch (std::out_of_range& e) {
34617       {
34618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34619       };
34620     } catch (std::exception& e) {
34621       {
34622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34623       };
34624     } catch (...) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34627       };
34628     }
34629   }
34630   jresult = result;
34631   return jresult;
34632 }
34633
34634
34635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34636   float jresult ;
34637   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34638   float arg2 ;
34639   float result;
34640
34641   arg1 = (Dali::CustomActorImpl *)jarg1;
34642   arg2 = (float)jarg2;
34643   {
34644     try {
34645       result = (float)(arg1)->GetHeightForWidth(arg2);
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34653       };
34654     } catch (...) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34657       };
34658     }
34659   }
34660   jresult = result;
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34666   float jresult ;
34667   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34668   float arg2 ;
34669   float result;
34670
34671   arg1 = (Dali::CustomActorImpl *)jarg1;
34672   arg2 = (float)jarg2;
34673   {
34674     try {
34675       result = (float)(arg1)->GetWidthForHeight(arg2);
34676     } catch (std::out_of_range& e) {
34677       {
34678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34679       };
34680     } catch (std::exception& e) {
34681       {
34682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34687       };
34688     }
34689   }
34690   jresult = result;
34691   return jresult;
34692 }
34693
34694
34695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34696   unsigned int jresult ;
34697   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34698   Dali::Dimension::Type arg2 ;
34699   bool result;
34700
34701   arg1 = (Dali::CustomActorImpl *)jarg1;
34702   arg2 = (Dali::Dimension::Type)jarg2;
34703   {
34704     try {
34705       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34717       };
34718     }
34719   }
34720   jresult = result;
34721   return jresult;
34722 }
34723
34724
34725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34726   unsigned int jresult ;
34727   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34728   bool result;
34729
34730   arg1 = (Dali::CustomActorImpl *)jarg1;
34731   {
34732     try {
34733       result = (bool)(arg1)->RelayoutDependentOnChildren();
34734     } catch (std::out_of_range& e) {
34735       {
34736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34737       };
34738     } catch (std::exception& e) {
34739       {
34740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34741       };
34742     } catch (...) {
34743       {
34744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34745       };
34746     }
34747   }
34748   jresult = result;
34749   return jresult;
34750 }
34751
34752
34753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34754   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34755   Dali::Dimension::Type arg2 ;
34756
34757   arg1 = (Dali::CustomActorImpl *)jarg1;
34758   arg2 = (Dali::Dimension::Type)jarg2;
34759   {
34760     try {
34761       (arg1)->OnCalculateRelayoutSize(arg2);
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34769       };
34770     } catch (...) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34773       };
34774     }
34775   }
34776 }
34777
34778
34779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34780   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34781   float arg2 ;
34782   Dali::Dimension::Type arg3 ;
34783
34784   arg1 = (Dali::CustomActorImpl *)jarg1;
34785   arg2 = (float)jarg2;
34786   arg3 = (Dali::Dimension::Type)jarg3;
34787   {
34788     try {
34789       (arg1)->OnLayoutNegotiated(arg2,arg3);
34790     } catch (std::out_of_range& e) {
34791       {
34792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34793       };
34794     } catch (std::exception& e) {
34795       {
34796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34797       };
34798     } catch (...) {
34799       {
34800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34801       };
34802     }
34803   }
34804 }
34805
34806
34807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34808   unsigned int jresult ;
34809   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34810   bool result;
34811
34812   arg1 = (Dali::CustomActorImpl *)jarg1;
34813   {
34814     try {
34815       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34816     } catch (std::out_of_range& e) {
34817       {
34818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34819       };
34820     } catch (std::exception& e) {
34821       {
34822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34823       };
34824     } catch (...) {
34825       {
34826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34827       };
34828     }
34829   }
34830   jresult = result;
34831   return jresult;
34832 }
34833
34834
34835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34836   unsigned int jresult ;
34837   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34838   bool result;
34839
34840   arg1 = (Dali::CustomActorImpl *)jarg1;
34841   {
34842     try {
34843       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34855       };
34856     }
34857   }
34858   jresult = result;
34859   return jresult;
34860 }
34861
34862
34863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34864   unsigned int jresult ;
34865   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34866   bool result;
34867
34868   arg1 = (Dali::CustomActorImpl *)jarg1;
34869   {
34870     try {
34871       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34879       };
34880     } catch (...) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34883       };
34884     }
34885   }
34886   jresult = result;
34887   return jresult;
34888 }
34889
34890
34891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34892   unsigned int jresult ;
34893   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34894   bool result;
34895
34896   arg1 = (Dali::CustomActorImpl *)jarg1;
34897   {
34898     try {
34899       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34900     } catch (std::out_of_range& e) {
34901       {
34902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34903       };
34904     } catch (std::exception& e) {
34905       {
34906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (...) {
34909       {
34910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34911       };
34912     }
34913   }
34914   jresult = result;
34915   return jresult;
34916 }
34917
34918
34919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34920   void * jresult ;
34921   Dali::CustomActor *result = 0 ;
34922
34923   {
34924     try {
34925       result = (Dali::CustomActor *)new Dali::CustomActor();
34926     } catch (std::out_of_range& e) {
34927       {
34928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34929       };
34930     } catch (std::exception& e) {
34931       {
34932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34933       };
34934     } catch (...) {
34935       {
34936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34937       };
34938     }
34939   }
34940   jresult = (void *)result;
34941   return jresult;
34942 }
34943
34944
34945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34946   void * jresult ;
34947   Dali::BaseHandle arg1 ;
34948   Dali::BaseHandle *argp1 ;
34949   Dali::CustomActor result;
34950
34951   argp1 = (Dali::BaseHandle *)jarg1;
34952   if (!argp1) {
34953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34954     return 0;
34955   }
34956   arg1 = *argp1;
34957   {
34958     try {
34959       result = Dali::CustomActor::DownCast(arg1);
34960     } catch (std::out_of_range& e) {
34961       {
34962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34963       };
34964     } catch (std::exception& e) {
34965       {
34966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34971       };
34972     }
34973   }
34974   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34975   return jresult;
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34980   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34981
34982   arg1 = (Dali::CustomActor *)jarg1;
34983   {
34984     try {
34985       delete arg1;
34986     } catch (std::out_of_range& e) {
34987       {
34988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34989       };
34990     } catch (std::exception& e) {
34991       {
34992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34993       };
34994     } catch (...) {
34995       {
34996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34997       };
34998     }
34999   }
35000 }
35001
35002
35003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35004   void * jresult ;
35005   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35006   Dali::CustomActorImpl *result = 0 ;
35007
35008   arg1 = (Dali::CustomActor *)jarg1;
35009   {
35010     try {
35011       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35012     } catch (std::out_of_range& e) {
35013       {
35014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35015       };
35016     } catch (std::exception& e) {
35017       {
35018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35019       };
35020     } catch (...) {
35021       {
35022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35023       };
35024     }
35025   }
35026   jresult = (void *)result;
35027   return jresult;
35028 }
35029
35030
35031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35032   void * jresult ;
35033   Dali::CustomActorImpl *arg1 = 0 ;
35034   Dali::CustomActor *result = 0 ;
35035
35036   arg1 = (Dali::CustomActorImpl *)jarg1;
35037   if (!arg1) {
35038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35039     return 0;
35040   }
35041   {
35042     try {
35043       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35044     } catch (std::out_of_range& e) {
35045       {
35046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35047       };
35048     } catch (std::exception& e) {
35049       {
35050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35051       };
35052     } catch (...) {
35053       {
35054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35055       };
35056     }
35057   }
35058   jresult = (void *)result;
35059   return jresult;
35060 }
35061
35062
35063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35064   void * jresult ;
35065   Dali::CustomActor *arg1 = 0 ;
35066   Dali::CustomActor *result = 0 ;
35067
35068   arg1 = (Dali::CustomActor *)jarg1;
35069   if (!arg1) {
35070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35071     return 0;
35072   }
35073   {
35074     try {
35075       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35076     } catch (std::out_of_range& e) {
35077       {
35078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35079       };
35080     } catch (std::exception& e) {
35081       {
35082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35083       };
35084     } catch (...) {
35085       {
35086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35087       };
35088     }
35089   }
35090   jresult = (void *)result;
35091   return jresult;
35092 }
35093
35094
35095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35096   void * jresult ;
35097   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35098   Dali::CustomActor *arg2 = 0 ;
35099   Dali::CustomActor *result = 0 ;
35100
35101   arg1 = (Dali::CustomActor *)jarg1;
35102   arg2 = (Dali::CustomActor *)jarg2;
35103   if (!arg2) {
35104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35105     return 0;
35106   }
35107   {
35108     try {
35109       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35110     } catch (std::out_of_range& e) {
35111       {
35112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35113       };
35114     } catch (std::exception& e) {
35115       {
35116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35117       };
35118     } catch (...) {
35119       {
35120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35121       };
35122     }
35123   }
35124   jresult = (void *)result;
35125   return jresult;
35126 }
35127
35128
35129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35130   int jresult ;
35131   int result;
35132
35133   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35134   jresult = (int)result;
35135   return jresult;
35136 }
35137
35138
35139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35140   int jresult ;
35141   int result;
35142
35143   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35144   jresult = (int)result;
35145   return jresult;
35146 }
35147
35148
35149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35150   int jresult ;
35151   int result;
35152
35153   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35154   jresult = (int)result;
35155   return jresult;
35156 }
35157
35158
35159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35160   int jresult ;
35161   int result;
35162
35163   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35164   jresult = (int)result;
35165   return jresult;
35166 }
35167
35168
35169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35170   int jresult ;
35171   int result;
35172
35173   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35174   jresult = (int)result;
35175   return jresult;
35176 }
35177
35178
35179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35180   int jresult ;
35181   int result;
35182
35183   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35184   jresult = (int)result;
35185   return jresult;
35186 }
35187
35188
35189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35190   int jresult ;
35191   int result;
35192
35193   result = (int)Dali::PanGestureDetector::Property::PANNING;
35194   jresult = (int)result;
35195   return jresult;
35196 }
35197
35198
35199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35200   void * jresult ;
35201   Dali::PanGestureDetector::Property *result = 0 ;
35202
35203   {
35204     try {
35205       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35206     } catch (std::out_of_range& e) {
35207       {
35208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35209       };
35210     } catch (std::exception& e) {
35211       {
35212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35213       };
35214     } catch (...) {
35215       {
35216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35217       };
35218     }
35219   }
35220   jresult = (void *)result;
35221   return jresult;
35222 }
35223
35224
35225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35226   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35227
35228   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35229   {
35230     try {
35231       delete arg1;
35232     } catch (std::out_of_range& e) {
35233       {
35234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35235       };
35236     } catch (std::exception& e) {
35237       {
35238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35243       };
35244     }
35245   }
35246 }
35247
35248
35249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35250   void * jresult ;
35251   Dali::Radian *result = 0 ;
35252
35253   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35254   jresult = (void *)result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35260   void * jresult ;
35261   Dali::Radian *result = 0 ;
35262
35263   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35264   jresult = (void *)result;
35265   return jresult;
35266 }
35267
35268
35269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35270   void * jresult ;
35271   Dali::Radian *result = 0 ;
35272
35273   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35274   jresult = (void *)result;
35275   return jresult;
35276 }
35277
35278
35279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35280   void * jresult ;
35281   Dali::Radian *result = 0 ;
35282
35283   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35284   jresult = (void *)result;
35285   return jresult;
35286 }
35287
35288
35289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35290   void * jresult ;
35291   Dali::Radian *result = 0 ;
35292
35293   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35294   jresult = (void *)result;
35295   return jresult;
35296 }
35297
35298
35299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35300   void * jresult ;
35301   Dali::Radian *result = 0 ;
35302
35303   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35304   jresult = (void *)result;
35305   return jresult;
35306 }
35307
35308
35309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35310   void * jresult ;
35311   Dali::Radian *result = 0 ;
35312
35313   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35314   jresult = (void *)result;
35315   return jresult;
35316 }
35317
35318
35319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35320   void * jresult ;
35321   Dali::PanGestureDetector *result = 0 ;
35322
35323   {
35324     try {
35325       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35326     } catch (std::out_of_range& e) {
35327       {
35328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (std::exception& e) {
35331       {
35332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35333       };
35334     } catch (...) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35337       };
35338     }
35339   }
35340   jresult = (void *)result;
35341   return jresult;
35342 }
35343
35344
35345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35346   void * jresult ;
35347   Dali::PanGestureDetector result;
35348
35349   {
35350     try {
35351       result = Dali::PanGestureDetector::New();
35352     } catch (std::out_of_range& e) {
35353       {
35354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35355       };
35356     } catch (std::exception& e) {
35357       {
35358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35359       };
35360     } catch (...) {
35361       {
35362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35363       };
35364     }
35365   }
35366   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35367   return jresult;
35368 }
35369
35370
35371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35372   void * jresult ;
35373   Dali::BaseHandle arg1 ;
35374   Dali::BaseHandle *argp1 ;
35375   Dali::PanGestureDetector result;
35376
35377   argp1 = (Dali::BaseHandle *)jarg1;
35378   if (!argp1) {
35379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35380     return 0;
35381   }
35382   arg1 = *argp1;
35383   {
35384     try {
35385       result = Dali::PanGestureDetector::DownCast(arg1);
35386     } catch (std::out_of_range& e) {
35387       {
35388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35389       };
35390     } catch (std::exception& e) {
35391       {
35392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35393       };
35394     } catch (...) {
35395       {
35396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35397       };
35398     }
35399   }
35400   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35401   return jresult;
35402 }
35403
35404
35405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35406   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35407
35408   arg1 = (Dali::PanGestureDetector *)jarg1;
35409   {
35410     try {
35411       delete arg1;
35412     } catch (std::out_of_range& e) {
35413       {
35414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35415       };
35416     } catch (std::exception& e) {
35417       {
35418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35419       };
35420     } catch (...) {
35421       {
35422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35423       };
35424     }
35425   }
35426 }
35427
35428
35429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35430   void * jresult ;
35431   Dali::PanGestureDetector *arg1 = 0 ;
35432   Dali::PanGestureDetector *result = 0 ;
35433
35434   arg1 = (Dali::PanGestureDetector *)jarg1;
35435   if (!arg1) {
35436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35437     return 0;
35438   }
35439   {
35440     try {
35441       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35442     } catch (std::out_of_range& e) {
35443       {
35444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35445       };
35446     } catch (std::exception& e) {
35447       {
35448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35453       };
35454     }
35455   }
35456   jresult = (void *)result;
35457   return jresult;
35458 }
35459
35460
35461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35462   void * jresult ;
35463   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35464   Dali::PanGestureDetector *arg2 = 0 ;
35465   Dali::PanGestureDetector *result = 0 ;
35466
35467   arg1 = (Dali::PanGestureDetector *)jarg1;
35468   arg2 = (Dali::PanGestureDetector *)jarg2;
35469   if (!arg2) {
35470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35471     return 0;
35472   }
35473   {
35474     try {
35475       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35476     } catch (std::out_of_range& e) {
35477       {
35478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35479       };
35480     } catch (std::exception& e) {
35481       {
35482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35483       };
35484     } catch (...) {
35485       {
35486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35487       };
35488     }
35489   }
35490   jresult = (void *)result;
35491   return jresult;
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35496   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35497   unsigned int arg2 ;
35498
35499   arg1 = (Dali::PanGestureDetector *)jarg1;
35500   arg2 = (unsigned int)jarg2;
35501   {
35502     try {
35503       (arg1)->SetMinimumTouchesRequired(arg2);
35504     } catch (std::out_of_range& e) {
35505       {
35506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35507       };
35508     } catch (std::exception& e) {
35509       {
35510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35511       };
35512     } catch (...) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35515       };
35516     }
35517   }
35518 }
35519
35520
35521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35522   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35523   unsigned int arg2 ;
35524
35525   arg1 = (Dali::PanGestureDetector *)jarg1;
35526   arg2 = (unsigned int)jarg2;
35527   {
35528     try {
35529       (arg1)->SetMaximumTouchesRequired(arg2);
35530     } catch (std::out_of_range& e) {
35531       {
35532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35533       };
35534     } catch (std::exception& e) {
35535       {
35536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35537       };
35538     } catch (...) {
35539       {
35540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35541       };
35542     }
35543   }
35544 }
35545
35546
35547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35548   unsigned int jresult ;
35549   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35550   unsigned int result;
35551
35552   arg1 = (Dali::PanGestureDetector *)jarg1;
35553   {
35554     try {
35555       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35556     } catch (std::out_of_range& e) {
35557       {
35558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35559       };
35560     } catch (std::exception& e) {
35561       {
35562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35563       };
35564     } catch (...) {
35565       {
35566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35567       };
35568     }
35569   }
35570   jresult = result;
35571   return jresult;
35572 }
35573
35574
35575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35576   unsigned int jresult ;
35577   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35578   unsigned int result;
35579
35580   arg1 = (Dali::PanGestureDetector *)jarg1;
35581   {
35582     try {
35583       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35584     } catch (std::out_of_range& e) {
35585       {
35586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35587       };
35588     } catch (std::exception& e) {
35589       {
35590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35591       };
35592     } catch (...) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35595       };
35596     }
35597   }
35598   jresult = result;
35599   return jresult;
35600 }
35601
35602
35603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35604   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35605   Dali::Radian arg2 ;
35606   Dali::Radian arg3 ;
35607   Dali::Radian *argp2 ;
35608   Dali::Radian *argp3 ;
35609
35610   arg1 = (Dali::PanGestureDetector *)jarg1;
35611   argp2 = (Dali::Radian *)jarg2;
35612   if (!argp2) {
35613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35614     return ;
35615   }
35616   arg2 = *argp2;
35617   argp3 = (Dali::Radian *)jarg3;
35618   if (!argp3) {
35619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35620     return ;
35621   }
35622   arg3 = *argp3;
35623   {
35624     try {
35625       (arg1)->AddAngle(arg2,arg3);
35626     } catch (std::out_of_range& e) {
35627       {
35628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35629       };
35630     } catch (std::exception& e) {
35631       {
35632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (...) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35637       };
35638     }
35639   }
35640 }
35641
35642
35643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35644   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35645   Dali::Radian arg2 ;
35646   Dali::Radian *argp2 ;
35647
35648   arg1 = (Dali::PanGestureDetector *)jarg1;
35649   argp2 = (Dali::Radian *)jarg2;
35650   if (!argp2) {
35651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35652     return ;
35653   }
35654   arg2 = *argp2;
35655   {
35656     try {
35657       (arg1)->AddAngle(arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (...) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35669       };
35670     }
35671   }
35672 }
35673
35674
35675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35676   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35677   Dali::Radian arg2 ;
35678   Dali::Radian arg3 ;
35679   Dali::Radian *argp2 ;
35680   Dali::Radian *argp3 ;
35681
35682   arg1 = (Dali::PanGestureDetector *)jarg1;
35683   argp2 = (Dali::Radian *)jarg2;
35684   if (!argp2) {
35685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35686     return ;
35687   }
35688   arg2 = *argp2;
35689   argp3 = (Dali::Radian *)jarg3;
35690   if (!argp3) {
35691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35692     return ;
35693   }
35694   arg3 = *argp3;
35695   {
35696     try {
35697       (arg1)->AddDirection(arg2,arg3);
35698     } catch (std::out_of_range& e) {
35699       {
35700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35701       };
35702     } catch (std::exception& e) {
35703       {
35704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35709       };
35710     }
35711   }
35712 }
35713
35714
35715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35716   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35717   Dali::Radian arg2 ;
35718   Dali::Radian *argp2 ;
35719
35720   arg1 = (Dali::PanGestureDetector *)jarg1;
35721   argp2 = (Dali::Radian *)jarg2;
35722   if (!argp2) {
35723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35724     return ;
35725   }
35726   arg2 = *argp2;
35727   {
35728     try {
35729       (arg1)->AddDirection(arg2);
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (...) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35741       };
35742     }
35743   }
35744 }
35745
35746
35747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35748   unsigned long jresult ;
35749   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35750   size_t result;
35751
35752   arg1 = (Dali::PanGestureDetector *)jarg1;
35753   {
35754     try {
35755       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35763       };
35764     } catch (...) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35767       };
35768     }
35769   }
35770   jresult = (unsigned long)result;
35771   return jresult;
35772 }
35773
35774
35775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35776   void * jresult ;
35777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35778   size_t arg2 ;
35779   Dali::PanGestureDetector::AngleThresholdPair result;
35780
35781   arg1 = (Dali::PanGestureDetector *)jarg1;
35782   arg2 = (size_t)jarg2;
35783   {
35784     try {
35785       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35786     } catch (std::out_of_range& e) {
35787       {
35788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35789       };
35790     } catch (std::exception& e) {
35791       {
35792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35793       };
35794     } catch (...) {
35795       {
35796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35797       };
35798     }
35799   }
35800   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35801   return jresult;
35802 }
35803
35804
35805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35806   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35807
35808   arg1 = (Dali::PanGestureDetector *)jarg1;
35809   {
35810     try {
35811       (arg1)->ClearAngles();
35812     } catch (std::out_of_range& e) {
35813       {
35814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35815       };
35816     } catch (std::exception& e) {
35817       {
35818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35819       };
35820     } catch (...) {
35821       {
35822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35823       };
35824     }
35825   }
35826 }
35827
35828
35829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35830   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35831   Dali::Radian arg2 ;
35832   Dali::Radian *argp2 ;
35833
35834   arg1 = (Dali::PanGestureDetector *)jarg1;
35835   argp2 = (Dali::Radian *)jarg2;
35836   if (!argp2) {
35837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35838     return ;
35839   }
35840   arg2 = *argp2;
35841   {
35842     try {
35843       (arg1)->RemoveAngle(arg2);
35844     } catch (std::out_of_range& e) {
35845       {
35846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35847       };
35848     } catch (std::exception& e) {
35849       {
35850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35851       };
35852     } catch (...) {
35853       {
35854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35855       };
35856     }
35857   }
35858 }
35859
35860
35861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35863   Dali::Radian arg2 ;
35864   Dali::Radian *argp2 ;
35865
35866   arg1 = (Dali::PanGestureDetector *)jarg1;
35867   argp2 = (Dali::Radian *)jarg2;
35868   if (!argp2) {
35869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35870     return ;
35871   }
35872   arg2 = *argp2;
35873   {
35874     try {
35875       (arg1)->RemoveDirection(arg2);
35876     } catch (std::out_of_range& e) {
35877       {
35878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35879       };
35880     } catch (std::exception& e) {
35881       {
35882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35883       };
35884     } catch (...) {
35885       {
35886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35887       };
35888     }
35889   }
35890 }
35891
35892
35893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35894   void * jresult ;
35895   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35896   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35897
35898   arg1 = (Dali::PanGestureDetector *)jarg1;
35899   {
35900     try {
35901       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35902     } catch (std::out_of_range& e) {
35903       {
35904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35905       };
35906     } catch (std::exception& e) {
35907       {
35908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35913       };
35914     }
35915   }
35916   jresult = (void *)result;
35917   return jresult;
35918 }
35919
35920
35921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35922   Dali::PanGesture *arg1 = 0 ;
35923
35924   arg1 = (Dali::PanGesture *)jarg1;
35925   if (!arg1) {
35926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35927     return ;
35928   }
35929   {
35930     try {
35931       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35932     } catch (std::out_of_range& e) {
35933       {
35934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35935       };
35936     } catch (std::exception& e) {
35937       {
35938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35943       };
35944     }
35945   }
35946 }
35947
35948
35949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35950   void * jresult ;
35951   Dali::PanGesture *result = 0 ;
35952
35953   {
35954     try {
35955       result = (Dali::PanGesture *)new Dali::PanGesture();
35956     } catch (std::out_of_range& e) {
35957       {
35958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (std::exception& e) {
35961       {
35962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35963       };
35964     } catch (...) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35967       };
35968     }
35969   }
35970   jresult = (void *)result;
35971   return jresult;
35972 }
35973
35974
35975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35976   void * jresult ;
35977   Dali::Gesture::State arg1 ;
35978   Dali::PanGesture *result = 0 ;
35979
35980   arg1 = (Dali::Gesture::State)jarg1;
35981   {
35982     try {
35983       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35984     } catch (std::out_of_range& e) {
35985       {
35986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35987       };
35988     } catch (std::exception& e) {
35989       {
35990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35991       };
35992     } catch (...) {
35993       {
35994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35995       };
35996     }
35997   }
35998   jresult = (void *)result;
35999   return jresult;
36000 }
36001
36002
36003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36004   void * jresult ;
36005   Dali::PanGesture *arg1 = 0 ;
36006   Dali::PanGesture *result = 0 ;
36007
36008   arg1 = (Dali::PanGesture *)jarg1;
36009   if (!arg1) {
36010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36011     return 0;
36012   }
36013   {
36014     try {
36015       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36016     } catch (std::out_of_range& e) {
36017       {
36018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36019       };
36020     } catch (std::exception& e) {
36021       {
36022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36023       };
36024     } catch (...) {
36025       {
36026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36027       };
36028     }
36029   }
36030   jresult = (void *)result;
36031   return jresult;
36032 }
36033
36034
36035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36036   void * jresult ;
36037   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36038   Dali::PanGesture *arg2 = 0 ;
36039   Dali::PanGesture *result = 0 ;
36040
36041   arg1 = (Dali::PanGesture *)jarg1;
36042   arg2 = (Dali::PanGesture *)jarg2;
36043   if (!arg2) {
36044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36045     return 0;
36046   }
36047   {
36048     try {
36049       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36050     } catch (std::out_of_range& e) {
36051       {
36052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36053       };
36054     } catch (std::exception& e) {
36055       {
36056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36061       };
36062     }
36063   }
36064   jresult = (void *)result;
36065   return jresult;
36066 }
36067
36068
36069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36070   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36071
36072   arg1 = (Dali::PanGesture *)jarg1;
36073   {
36074     try {
36075       delete arg1;
36076     } catch (std::out_of_range& e) {
36077       {
36078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36079       };
36080     } catch (std::exception& e) {
36081       {
36082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36083       };
36084     } catch (...) {
36085       {
36086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36087       };
36088     }
36089   }
36090 }
36091
36092
36093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36094   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36095   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36096
36097   arg1 = (Dali::PanGesture *)jarg1;
36098   arg2 = (Dali::Vector2 *)jarg2;
36099   if (arg1) (arg1)->velocity = *arg2;
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36104   void * jresult ;
36105   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36106   Dali::Vector2 *result = 0 ;
36107
36108   arg1 = (Dali::PanGesture *)jarg1;
36109   result = (Dali::Vector2 *)& ((arg1)->velocity);
36110   jresult = (void *)result;
36111   return jresult;
36112 }
36113
36114
36115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36116   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36117   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36118
36119   arg1 = (Dali::PanGesture *)jarg1;
36120   arg2 = (Dali::Vector2 *)jarg2;
36121   if (arg1) (arg1)->displacement = *arg2;
36122 }
36123
36124
36125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36126   void * jresult ;
36127   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36128   Dali::Vector2 *result = 0 ;
36129
36130   arg1 = (Dali::PanGesture *)jarg1;
36131   result = (Dali::Vector2 *)& ((arg1)->displacement);
36132   jresult = (void *)result;
36133   return jresult;
36134 }
36135
36136
36137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36138   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36139   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36140
36141   arg1 = (Dali::PanGesture *)jarg1;
36142   arg2 = (Dali::Vector2 *)jarg2;
36143   if (arg1) (arg1)->position = *arg2;
36144 }
36145
36146
36147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36148   void * jresult ;
36149   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36150   Dali::Vector2 *result = 0 ;
36151
36152   arg1 = (Dali::PanGesture *)jarg1;
36153   result = (Dali::Vector2 *)& ((arg1)->position);
36154   jresult = (void *)result;
36155   return jresult;
36156 }
36157
36158
36159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36160   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36161   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36162
36163   arg1 = (Dali::PanGesture *)jarg1;
36164   arg2 = (Dali::Vector2 *)jarg2;
36165   if (arg1) (arg1)->screenVelocity = *arg2;
36166 }
36167
36168
36169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36170   void * jresult ;
36171   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36172   Dali::Vector2 *result = 0 ;
36173
36174   arg1 = (Dali::PanGesture *)jarg1;
36175   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36176   jresult = (void *)result;
36177   return jresult;
36178 }
36179
36180
36181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36182   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36183   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36184
36185   arg1 = (Dali::PanGesture *)jarg1;
36186   arg2 = (Dali::Vector2 *)jarg2;
36187   if (arg1) (arg1)->screenDisplacement = *arg2;
36188 }
36189
36190
36191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36192   void * jresult ;
36193   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36194   Dali::Vector2 *result = 0 ;
36195
36196   arg1 = (Dali::PanGesture *)jarg1;
36197   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36198   jresult = (void *)result;
36199   return jresult;
36200 }
36201
36202
36203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36204   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36205   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36206
36207   arg1 = (Dali::PanGesture *)jarg1;
36208   arg2 = (Dali::Vector2 *)jarg2;
36209   if (arg1) (arg1)->screenPosition = *arg2;
36210 }
36211
36212
36213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36214   void * jresult ;
36215   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36216   Dali::Vector2 *result = 0 ;
36217
36218   arg1 = (Dali::PanGesture *)jarg1;
36219   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36220   jresult = (void *)result;
36221   return jresult;
36222 }
36223
36224
36225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36227   unsigned int arg2 ;
36228
36229   arg1 = (Dali::PanGesture *)jarg1;
36230   arg2 = (unsigned int)jarg2;
36231   if (arg1) (arg1)->numberOfTouches = arg2;
36232 }
36233
36234
36235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36236   unsigned int jresult ;
36237   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36238   unsigned int result;
36239
36240   arg1 = (Dali::PanGesture *)jarg1;
36241   result = (unsigned int) ((arg1)->numberOfTouches);
36242   jresult = result;
36243   return jresult;
36244 }
36245
36246
36247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36248   float jresult ;
36249   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36250   float result;
36251
36252   arg1 = (Dali::PanGesture *)jarg1;
36253   {
36254     try {
36255       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36256     } catch (std::out_of_range& e) {
36257       {
36258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36259       };
36260     } catch (std::exception& e) {
36261       {
36262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36263       };
36264     } catch (...) {
36265       {
36266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36267       };
36268     }
36269   }
36270   jresult = result;
36271   return jresult;
36272 }
36273
36274
36275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36276   float jresult ;
36277   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36278   float result;
36279
36280   arg1 = (Dali::PanGesture *)jarg1;
36281   {
36282     try {
36283       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36284     } catch (std::out_of_range& e) {
36285       {
36286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36287       };
36288     } catch (std::exception& e) {
36289       {
36290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (...) {
36293       {
36294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36295       };
36296     }
36297   }
36298   jresult = result;
36299   return jresult;
36300 }
36301
36302
36303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36304   float jresult ;
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   float result;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   {
36310     try {
36311       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36312     } catch (std::out_of_range& e) {
36313       {
36314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36315       };
36316     } catch (std::exception& e) {
36317       {
36318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36319       };
36320     } catch (...) {
36321       {
36322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36323       };
36324     }
36325   }
36326   jresult = result;
36327   return jresult;
36328 }
36329
36330
36331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36332   float jresult ;
36333   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36334   float result;
36335
36336   arg1 = (Dali::PanGesture *)jarg1;
36337   {
36338     try {
36339       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36340     } catch (std::out_of_range& e) {
36341       {
36342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36343       };
36344     } catch (std::exception& e) {
36345       {
36346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36347       };
36348     } catch (...) {
36349       {
36350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36351       };
36352     }
36353   }
36354   jresult = result;
36355   return jresult;
36356 }
36357
36358
36359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36360   void * jresult ;
36361   Dali::PinchGestureDetector *result = 0 ;
36362
36363   {
36364     try {
36365       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36366     } catch (std::out_of_range& e) {
36367       {
36368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36369       };
36370     } catch (std::exception& e) {
36371       {
36372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36373       };
36374     } catch (...) {
36375       {
36376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36377       };
36378     }
36379   }
36380   jresult = (void *)result;
36381   return jresult;
36382 }
36383
36384
36385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36386   void * jresult ;
36387   Dali::PinchGestureDetector result;
36388
36389   {
36390     try {
36391       result = Dali::PinchGestureDetector::New();
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36412   void * jresult ;
36413   Dali::BaseHandle arg1 ;
36414   Dali::BaseHandle *argp1 ;
36415   Dali::PinchGestureDetector result;
36416
36417   argp1 = (Dali::BaseHandle *)jarg1;
36418   if (!argp1) {
36419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36420     return 0;
36421   }
36422   arg1 = *argp1;
36423   {
36424     try {
36425       result = Dali::PinchGestureDetector::DownCast(arg1);
36426     } catch (std::out_of_range& e) {
36427       {
36428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36429       };
36430     } catch (std::exception& e) {
36431       {
36432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36433       };
36434     } catch (...) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36437       };
36438     }
36439   }
36440   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36446   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36447
36448   arg1 = (Dali::PinchGestureDetector *)jarg1;
36449   {
36450     try {
36451       delete arg1;
36452     } catch (std::out_of_range& e) {
36453       {
36454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36455       };
36456     } catch (std::exception& e) {
36457       {
36458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36459       };
36460     } catch (...) {
36461       {
36462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36463       };
36464     }
36465   }
36466 }
36467
36468
36469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36470   void * jresult ;
36471   Dali::PinchGestureDetector *arg1 = 0 ;
36472   Dali::PinchGestureDetector *result = 0 ;
36473
36474   arg1 = (Dali::PinchGestureDetector *)jarg1;
36475   if (!arg1) {
36476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36477     return 0;
36478   }
36479   {
36480     try {
36481       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36482     } catch (std::out_of_range& e) {
36483       {
36484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (std::exception& e) {
36487       {
36488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (...) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36493       };
36494     }
36495   }
36496   jresult = (void *)result;
36497   return jresult;
36498 }
36499
36500
36501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36502   void * jresult ;
36503   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36504   Dali::PinchGestureDetector *arg2 = 0 ;
36505   Dali::PinchGestureDetector *result = 0 ;
36506
36507   arg1 = (Dali::PinchGestureDetector *)jarg1;
36508   arg2 = (Dali::PinchGestureDetector *)jarg2;
36509   if (!arg2) {
36510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36511     return 0;
36512   }
36513   {
36514     try {
36515       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36516     } catch (std::out_of_range& e) {
36517       {
36518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36519       };
36520     } catch (std::exception& e) {
36521       {
36522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36527       };
36528     }
36529   }
36530   jresult = (void *)result;
36531   return jresult;
36532 }
36533
36534
36535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36536   void * jresult ;
36537   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36538   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36539
36540   arg1 = (Dali::PinchGestureDetector *)jarg1;
36541   {
36542     try {
36543       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36544     } catch (std::out_of_range& e) {
36545       {
36546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36547       };
36548     } catch (std::exception& e) {
36549       {
36550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36551       };
36552     } catch (...) {
36553       {
36554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36555       };
36556     }
36557   }
36558   jresult = (void *)result;
36559   return jresult;
36560 }
36561
36562
36563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36564   void * jresult ;
36565   Dali::Gesture::State arg1 ;
36566   Dali::PinchGesture *result = 0 ;
36567
36568   arg1 = (Dali::Gesture::State)jarg1;
36569   {
36570     try {
36571       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36572     } catch (std::out_of_range& e) {
36573       {
36574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36575       };
36576     } catch (std::exception& e) {
36577       {
36578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36579       };
36580     } catch (...) {
36581       {
36582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36583       };
36584     }
36585   }
36586   jresult = (void *)result;
36587   return jresult;
36588 }
36589
36590
36591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36592   void * jresult ;
36593   Dali::PinchGesture *arg1 = 0 ;
36594   Dali::PinchGesture *result = 0 ;
36595
36596   arg1 = (Dali::PinchGesture *)jarg1;
36597   if (!arg1) {
36598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36599     return 0;
36600   }
36601   {
36602     try {
36603       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36604     } catch (std::out_of_range& e) {
36605       {
36606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (std::exception& e) {
36609       {
36610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36615       };
36616     }
36617   }
36618   jresult = (void *)result;
36619   return jresult;
36620 }
36621
36622
36623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36624   void * jresult ;
36625   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36626   Dali::PinchGesture *arg2 = 0 ;
36627   Dali::PinchGesture *result = 0 ;
36628
36629   arg1 = (Dali::PinchGesture *)jarg1;
36630   arg2 = (Dali::PinchGesture *)jarg2;
36631   if (!arg2) {
36632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36633     return 0;
36634   }
36635   {
36636     try {
36637       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36638     } catch (std::out_of_range& e) {
36639       {
36640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36641       };
36642     } catch (std::exception& e) {
36643       {
36644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36645       };
36646     } catch (...) {
36647       {
36648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36649       };
36650     }
36651   }
36652   jresult = (void *)result;
36653   return jresult;
36654 }
36655
36656
36657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36658   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36659
36660   arg1 = (Dali::PinchGesture *)jarg1;
36661   {
36662     try {
36663       delete arg1;
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36671       };
36672     } catch (...) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36675       };
36676     }
36677   }
36678 }
36679
36680
36681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36682   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36683   float arg2 ;
36684
36685   arg1 = (Dali::PinchGesture *)jarg1;
36686   arg2 = (float)jarg2;
36687   if (arg1) (arg1)->scale = arg2;
36688 }
36689
36690
36691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36692   float jresult ;
36693   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36694   float result;
36695
36696   arg1 = (Dali::PinchGesture *)jarg1;
36697   result = (float) ((arg1)->scale);
36698   jresult = result;
36699   return jresult;
36700 }
36701
36702
36703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36704   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36705   float arg2 ;
36706
36707   arg1 = (Dali::PinchGesture *)jarg1;
36708   arg2 = (float)jarg2;
36709   if (arg1) (arg1)->speed = arg2;
36710 }
36711
36712
36713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36714   float jresult ;
36715   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36716   float result;
36717
36718   arg1 = (Dali::PinchGesture *)jarg1;
36719   result = (float) ((arg1)->speed);
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36726   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36727   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36728
36729   arg1 = (Dali::PinchGesture *)jarg1;
36730   arg2 = (Dali::Vector2 *)jarg2;
36731   if (arg1) (arg1)->screenCenterPoint = *arg2;
36732 }
36733
36734
36735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36736   void * jresult ;
36737   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36738   Dali::Vector2 *result = 0 ;
36739
36740   arg1 = (Dali::PinchGesture *)jarg1;
36741   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36742   jresult = (void *)result;
36743   return jresult;
36744 }
36745
36746
36747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36748   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36749   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36750
36751   arg1 = (Dali::PinchGesture *)jarg1;
36752   arg2 = (Dali::Vector2 *)jarg2;
36753   if (arg1) (arg1)->localCenterPoint = *arg2;
36754 }
36755
36756
36757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36758   void * jresult ;
36759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36760   Dali::Vector2 *result = 0 ;
36761
36762   arg1 = (Dali::PinchGesture *)jarg1;
36763   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36764   jresult = (void *)result;
36765   return jresult;
36766 }
36767
36768
36769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36770   void * jresult ;
36771   Dali::TapGestureDetector *result = 0 ;
36772
36773   {
36774     try {
36775       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36776     } catch (std::out_of_range& e) {
36777       {
36778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36779       };
36780     } catch (std::exception& e) {
36781       {
36782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36783       };
36784     } catch (...) {
36785       {
36786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36787       };
36788     }
36789   }
36790   jresult = (void *)result;
36791   return jresult;
36792 }
36793
36794
36795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36796   void * jresult ;
36797   Dali::TapGestureDetector result;
36798
36799   {
36800     try {
36801       result = Dali::TapGestureDetector::New();
36802     } catch (std::out_of_range& e) {
36803       {
36804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (std::exception& e) {
36807       {
36808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36809       };
36810     } catch (...) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36813       };
36814     }
36815   }
36816   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36817   return jresult;
36818 }
36819
36820
36821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36822   void * jresult ;
36823   unsigned int arg1 ;
36824   Dali::TapGestureDetector result;
36825
36826   arg1 = (unsigned int)jarg1;
36827   {
36828     try {
36829       result = Dali::TapGestureDetector::New(arg1);
36830     } catch (std::out_of_range& e) {
36831       {
36832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36833       };
36834     } catch (std::exception& e) {
36835       {
36836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36837       };
36838     } catch (...) {
36839       {
36840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36841       };
36842     }
36843   }
36844   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36850   void * jresult ;
36851   Dali::BaseHandle arg1 ;
36852   Dali::BaseHandle *argp1 ;
36853   Dali::TapGestureDetector result;
36854
36855   argp1 = (Dali::BaseHandle *)jarg1;
36856   if (!argp1) {
36857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36858     return 0;
36859   }
36860   arg1 = *argp1;
36861   {
36862     try {
36863       result = Dali::TapGestureDetector::DownCast(arg1);
36864     } catch (std::out_of_range& e) {
36865       {
36866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36867       };
36868     } catch (std::exception& e) {
36869       {
36870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (...) {
36873       {
36874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36875       };
36876     }
36877   }
36878   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36879   return jresult;
36880 }
36881
36882
36883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36884   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36885
36886   arg1 = (Dali::TapGestureDetector *)jarg1;
36887   {
36888     try {
36889       delete arg1;
36890     } catch (std::out_of_range& e) {
36891       {
36892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36893       };
36894     } catch (std::exception& e) {
36895       {
36896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36897       };
36898     } catch (...) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36901       };
36902     }
36903   }
36904 }
36905
36906
36907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36908   void * jresult ;
36909   Dali::TapGestureDetector *arg1 = 0 ;
36910   Dali::TapGestureDetector *result = 0 ;
36911
36912   arg1 = (Dali::TapGestureDetector *)jarg1;
36913   if (!arg1) {
36914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36915     return 0;
36916   }
36917   {
36918     try {
36919       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36920     } catch (std::out_of_range& e) {
36921       {
36922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36923       };
36924     } catch (std::exception& e) {
36925       {
36926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36927       };
36928     } catch (...) {
36929       {
36930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36931       };
36932     }
36933   }
36934   jresult = (void *)result;
36935   return jresult;
36936 }
36937
36938
36939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36940   void * jresult ;
36941   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36942   Dali::TapGestureDetector *arg2 = 0 ;
36943   Dali::TapGestureDetector *result = 0 ;
36944
36945   arg1 = (Dali::TapGestureDetector *)jarg1;
36946   arg2 = (Dali::TapGestureDetector *)jarg2;
36947   if (!arg2) {
36948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36949     return 0;
36950   }
36951   {
36952     try {
36953       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36954     } catch (std::out_of_range& e) {
36955       {
36956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (std::exception& e) {
36959       {
36960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36961       };
36962     } catch (...) {
36963       {
36964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36965       };
36966     }
36967   }
36968   jresult = (void *)result;
36969   return jresult;
36970 }
36971
36972
36973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36974   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36975   unsigned int arg2 ;
36976
36977   arg1 = (Dali::TapGestureDetector *)jarg1;
36978   arg2 = (unsigned int)jarg2;
36979   {
36980     try {
36981       (arg1)->SetMinimumTapsRequired(arg2);
36982     } catch (std::out_of_range& e) {
36983       {
36984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36985       };
36986     } catch (std::exception& e) {
36987       {
36988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36989       };
36990     } catch (...) {
36991       {
36992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36993       };
36994     }
36995   }
36996 }
36997
36998
36999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37000   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37001   unsigned int arg2 ;
37002
37003   arg1 = (Dali::TapGestureDetector *)jarg1;
37004   arg2 = (unsigned int)jarg2;
37005   {
37006     try {
37007       (arg1)->SetMaximumTapsRequired(arg2);
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37015       };
37016     } catch (...) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37019       };
37020     }
37021   }
37022 }
37023
37024
37025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37026   unsigned int jresult ;
37027   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37028   unsigned int result;
37029
37030   arg1 = (Dali::TapGestureDetector *)jarg1;
37031   {
37032     try {
37033       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37034     } catch (std::out_of_range& e) {
37035       {
37036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37037       };
37038     } catch (std::exception& e) {
37039       {
37040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (...) {
37043       {
37044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37045       };
37046     }
37047   }
37048   jresult = result;
37049   return jresult;
37050 }
37051
37052
37053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37054   unsigned int jresult ;
37055   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37056   unsigned int result;
37057
37058   arg1 = (Dali::TapGestureDetector *)jarg1;
37059   {
37060     try {
37061       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37062     } catch (std::out_of_range& e) {
37063       {
37064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37065       };
37066     } catch (std::exception& e) {
37067       {
37068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (...) {
37071       {
37072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37073       };
37074     }
37075   }
37076   jresult = result;
37077   return jresult;
37078 }
37079
37080
37081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37082   void * jresult ;
37083   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37084   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37085
37086   arg1 = (Dali::TapGestureDetector *)jarg1;
37087   {
37088     try {
37089       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37090     } catch (std::out_of_range& e) {
37091       {
37092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37093       };
37094     } catch (std::exception& e) {
37095       {
37096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37097       };
37098     } catch (...) {
37099       {
37100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37101       };
37102     }
37103   }
37104   jresult = (void *)result;
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37110   void * jresult ;
37111   Dali::TapGesture *result = 0 ;
37112
37113   {
37114     try {
37115       result = (Dali::TapGesture *)new Dali::TapGesture();
37116     } catch (std::out_of_range& e) {
37117       {
37118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37119       };
37120     } catch (std::exception& e) {
37121       {
37122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37123       };
37124     } catch (...) {
37125       {
37126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37127       };
37128     }
37129   }
37130   jresult = (void *)result;
37131   return jresult;
37132 }
37133
37134
37135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37136   void * jresult ;
37137   Dali::TapGesture *arg1 = 0 ;
37138   Dali::TapGesture *result = 0 ;
37139
37140   arg1 = (Dali::TapGesture *)jarg1;
37141   if (!arg1) {
37142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37143     return 0;
37144   }
37145   {
37146     try {
37147       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37148     } catch (std::out_of_range& e) {
37149       {
37150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37151       };
37152     } catch (std::exception& e) {
37153       {
37154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37155       };
37156     } catch (...) {
37157       {
37158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37159       };
37160     }
37161   }
37162   jresult = (void *)result;
37163   return jresult;
37164 }
37165
37166
37167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37168   void * jresult ;
37169   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37170   Dali::TapGesture *arg2 = 0 ;
37171   Dali::TapGesture *result = 0 ;
37172
37173   arg1 = (Dali::TapGesture *)jarg1;
37174   arg2 = (Dali::TapGesture *)jarg2;
37175   if (!arg2) {
37176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37177     return 0;
37178   }
37179   {
37180     try {
37181       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37182     } catch (std::out_of_range& e) {
37183       {
37184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37185       };
37186     } catch (std::exception& e) {
37187       {
37188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37189       };
37190     } catch (...) {
37191       {
37192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37193       };
37194     }
37195   }
37196   jresult = (void *)result;
37197   return jresult;
37198 }
37199
37200
37201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37202   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37203
37204   arg1 = (Dali::TapGesture *)jarg1;
37205   {
37206     try {
37207       delete arg1;
37208     } catch (std::out_of_range& e) {
37209       {
37210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37211       };
37212     } catch (std::exception& e) {
37213       {
37214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37215       };
37216     } catch (...) {
37217       {
37218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37219       };
37220     }
37221   }
37222 }
37223
37224
37225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37226   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37227   unsigned int arg2 ;
37228
37229   arg1 = (Dali::TapGesture *)jarg1;
37230   arg2 = (unsigned int)jarg2;
37231   if (arg1) (arg1)->numberOfTaps = arg2;
37232 }
37233
37234
37235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37236   unsigned int jresult ;
37237   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37238   unsigned int result;
37239
37240   arg1 = (Dali::TapGesture *)jarg1;
37241   result = (unsigned int) ((arg1)->numberOfTaps);
37242   jresult = result;
37243   return jresult;
37244 }
37245
37246
37247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37248   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37249   unsigned int arg2 ;
37250
37251   arg1 = (Dali::TapGesture *)jarg1;
37252   arg2 = (unsigned int)jarg2;
37253   if (arg1) (arg1)->numberOfTouches = arg2;
37254 }
37255
37256
37257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37258   unsigned int jresult ;
37259   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37260   unsigned int result;
37261
37262   arg1 = (Dali::TapGesture *)jarg1;
37263   result = (unsigned int) ((arg1)->numberOfTouches);
37264   jresult = result;
37265   return jresult;
37266 }
37267
37268
37269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37270   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37271   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37272
37273   arg1 = (Dali::TapGesture *)jarg1;
37274   arg2 = (Dali::Vector2 *)jarg2;
37275   if (arg1) (arg1)->screenPoint = *arg2;
37276 }
37277
37278
37279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37280   void * jresult ;
37281   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37282   Dali::Vector2 *result = 0 ;
37283
37284   arg1 = (Dali::TapGesture *)jarg1;
37285   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37286   jresult = (void *)result;
37287   return jresult;
37288 }
37289
37290
37291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37292   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37293   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37294
37295   arg1 = (Dali::TapGesture *)jarg1;
37296   arg2 = (Dali::Vector2 *)jarg2;
37297   if (arg1) (arg1)->localPoint = *arg2;
37298 }
37299
37300
37301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37302   void * jresult ;
37303   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37304   Dali::Vector2 *result = 0 ;
37305
37306   arg1 = (Dali::TapGesture *)jarg1;
37307   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37314   void * jresult ;
37315   Dali::AlphaFunction *result = 0 ;
37316
37317   {
37318     try {
37319       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37320     } catch (std::out_of_range& e) {
37321       {
37322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37323       };
37324     } catch (std::exception& e) {
37325       {
37326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37327       };
37328     } catch (...) {
37329       {
37330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37331       };
37332     }
37333   }
37334   jresult = (void *)result;
37335   return jresult;
37336 }
37337
37338
37339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37340   void * jresult ;
37341   Dali::AlphaFunction::BuiltinFunction arg1 ;
37342   Dali::AlphaFunction *result = 0 ;
37343
37344   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37345   {
37346     try {
37347       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37348     } catch (std::out_of_range& e) {
37349       {
37350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37351       };
37352     } catch (std::exception& e) {
37353       {
37354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37355       };
37356     } catch (...) {
37357       {
37358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37359       };
37360     }
37361   }
37362   jresult = (void *)result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37368   void * jresult ;
37369   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37370   Dali::AlphaFunction *result = 0 ;
37371
37372   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37373   {
37374     try {
37375       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37376     } catch (std::out_of_range& e) {
37377       {
37378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37379       };
37380     } catch (std::exception& e) {
37381       {
37382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37383       };
37384     } catch (...) {
37385       {
37386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37387       };
37388     }
37389   }
37390   jresult = (void *)result;
37391   return jresult;
37392 }
37393
37394
37395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37396   void * jresult ;
37397   Dali::Vector2 *arg1 = 0 ;
37398   Dali::Vector2 *arg2 = 0 ;
37399   Dali::AlphaFunction *result = 0 ;
37400
37401   arg1 = (Dali::Vector2 *)jarg1;
37402   if (!arg1) {
37403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37404     return 0;
37405   }
37406   arg2 = (Dali::Vector2 *)jarg2;
37407   if (!arg2) {
37408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37409     return 0;
37410   }
37411   {
37412     try {
37413       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37414     } catch (std::out_of_range& e) {
37415       {
37416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37417       };
37418     } catch (std::exception& e) {
37419       {
37420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37421       };
37422     } catch (...) {
37423       {
37424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37425       };
37426     }
37427   }
37428   jresult = (void *)result;
37429   return jresult;
37430 }
37431
37432
37433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37434   void * jresult ;
37435   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37436   Dali::Vector4 result;
37437
37438   arg1 = (Dali::AlphaFunction *)jarg1;
37439   {
37440     try {
37441       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37442     } catch (std::out_of_range& e) {
37443       {
37444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37445       };
37446     } catch (std::exception& e) {
37447       {
37448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (...) {
37451       {
37452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37453       };
37454     }
37455   }
37456   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37457   return jresult;
37458 }
37459
37460
37461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37462   void * jresult ;
37463   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37464   Dali::AlphaFunctionPrototype result;
37465
37466   arg1 = (Dali::AlphaFunction *)jarg1;
37467   {
37468     try {
37469       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37470     } catch (std::out_of_range& e) {
37471       {
37472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37473       };
37474     } catch (std::exception& e) {
37475       {
37476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37477       };
37478     } catch (...) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37481       };
37482     }
37483   }
37484   jresult = (void *)result;
37485   return jresult;
37486 }
37487
37488
37489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37490   int jresult ;
37491   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37492   Dali::AlphaFunction::BuiltinFunction result;
37493
37494   arg1 = (Dali::AlphaFunction *)jarg1;
37495   {
37496     try {
37497       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37498     } catch (std::out_of_range& e) {
37499       {
37500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37501       };
37502     } catch (std::exception& e) {
37503       {
37504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37505       };
37506     } catch (...) {
37507       {
37508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37509       };
37510     }
37511   }
37512   jresult = (int)result;
37513   return jresult;
37514 }
37515
37516
37517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37518   int jresult ;
37519   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37520   Dali::AlphaFunction::Mode result;
37521
37522   arg1 = (Dali::AlphaFunction *)jarg1;
37523   {
37524     try {
37525       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (...) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37537       };
37538     }
37539   }
37540   jresult = (int)result;
37541   return jresult;
37542 }
37543
37544
37545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37546   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37547
37548   arg1 = (Dali::AlphaFunction *)jarg1;
37549   {
37550     try {
37551       delete arg1;
37552     } catch (std::out_of_range& e) {
37553       {
37554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37555       };
37556     } catch (std::exception& e) {
37557       {
37558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37559       };
37560     } catch (...) {
37561       {
37562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37563       };
37564     }
37565   }
37566 }
37567
37568
37569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37570   void * jresult ;
37571   Dali::KeyFrames result;
37572
37573   {
37574     try {
37575       result = Dali::KeyFrames::New();
37576     } catch (std::out_of_range& e) {
37577       {
37578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37579       };
37580     } catch (std::exception& e) {
37581       {
37582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37583       };
37584     } catch (...) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37587       };
37588     }
37589   }
37590   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37591   return jresult;
37592 }
37593
37594
37595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37596   void * jresult ;
37597   Dali::BaseHandle arg1 ;
37598   Dali::BaseHandle *argp1 ;
37599   Dali::KeyFrames result;
37600
37601   argp1 = (Dali::BaseHandle *)jarg1;
37602   if (!argp1) {
37603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37604     return 0;
37605   }
37606   arg1 = *argp1;
37607   {
37608     try {
37609       result = Dali::KeyFrames::DownCast(arg1);
37610     } catch (std::out_of_range& e) {
37611       {
37612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37613       };
37614     } catch (std::exception& e) {
37615       {
37616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37617       };
37618     } catch (...) {
37619       {
37620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37621       };
37622     }
37623   }
37624   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37625   return jresult;
37626 }
37627
37628
37629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37630   void * jresult ;
37631   Dali::KeyFrames *result = 0 ;
37632
37633   {
37634     try {
37635       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37636     } catch (std::out_of_range& e) {
37637       {
37638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37639       };
37640     } catch (std::exception& e) {
37641       {
37642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37643       };
37644     } catch (...) {
37645       {
37646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37647       };
37648     }
37649   }
37650   jresult = (void *)result;
37651   return jresult;
37652 }
37653
37654
37655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37656   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37657
37658   arg1 = (Dali::KeyFrames *)jarg1;
37659   {
37660     try {
37661       delete arg1;
37662     } catch (std::out_of_range& e) {
37663       {
37664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (std::exception& e) {
37667       {
37668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676 }
37677
37678
37679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37680   void * jresult ;
37681   Dali::KeyFrames *arg1 = 0 ;
37682   Dali::KeyFrames *result = 0 ;
37683
37684   arg1 = (Dali::KeyFrames *)jarg1;
37685   if (!arg1) {
37686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37687     return 0;
37688   }
37689   {
37690     try {
37691       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37692     } catch (std::out_of_range& e) {
37693       {
37694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37695       };
37696     } catch (std::exception& e) {
37697       {
37698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37699       };
37700     } catch (...) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37703       };
37704     }
37705   }
37706   jresult = (void *)result;
37707   return jresult;
37708 }
37709
37710
37711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37712   void * jresult ;
37713   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37714   Dali::KeyFrames *arg2 = 0 ;
37715   Dali::KeyFrames *result = 0 ;
37716
37717   arg1 = (Dali::KeyFrames *)jarg1;
37718   arg2 = (Dali::KeyFrames *)jarg2;
37719   if (!arg2) {
37720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37721     return 0;
37722   }
37723   {
37724     try {
37725       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37726     } catch (std::out_of_range& e) {
37727       {
37728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37729       };
37730     } catch (std::exception& e) {
37731       {
37732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37733       };
37734     } catch (...) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37737       };
37738     }
37739   }
37740   jresult = (void *)result;
37741   return jresult;
37742 }
37743
37744
37745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37746   int jresult ;
37747   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37748   Dali::Property::Type result;
37749
37750   arg1 = (Dali::KeyFrames *)jarg1;
37751   {
37752     try {
37753       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37754     } catch (std::out_of_range& e) {
37755       {
37756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37757       };
37758     } catch (std::exception& e) {
37759       {
37760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (...) {
37763       {
37764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37765       };
37766     }
37767   }
37768   jresult = (int)result;
37769   return jresult;
37770 }
37771
37772
37773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37774   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37775   float arg2 ;
37776   Dali::Property::Value arg3 ;
37777   Dali::Property::Value *argp3 ;
37778
37779   arg1 = (Dali::KeyFrames *)jarg1;
37780   arg2 = (float)jarg2;
37781   argp3 = (Dali::Property::Value *)jarg3;
37782   if (!argp3) {
37783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37784     return ;
37785   }
37786   arg3 = *argp3;
37787   {
37788     try {
37789       (arg1)->Add(arg2,arg3);
37790     } catch (std::out_of_range& e) {
37791       {
37792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (std::exception& e) {
37795       {
37796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804 }
37805
37806
37807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37808   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37809   float arg2 ;
37810   Dali::Property::Value arg3 ;
37811   Dali::AlphaFunction arg4 ;
37812   Dali::Property::Value *argp3 ;
37813   Dali::AlphaFunction *argp4 ;
37814
37815   arg1 = (Dali::KeyFrames *)jarg1;
37816   arg2 = (float)jarg2;
37817   argp3 = (Dali::Property::Value *)jarg3;
37818   if (!argp3) {
37819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37820     return ;
37821   }
37822   arg3 = *argp3;
37823   argp4 = (Dali::AlphaFunction *)jarg4;
37824   if (!argp4) {
37825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37826     return ;
37827   }
37828   arg4 = *argp4;
37829   {
37830     try {
37831       (arg1)->Add(arg2,arg3,arg4);
37832     } catch (std::out_of_range& e) {
37833       {
37834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37835       };
37836     } catch (std::exception& e) {
37837       {
37838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37843       };
37844     }
37845   }
37846 }
37847
37848
37849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37850   int jresult ;
37851   int result;
37852
37853   result = (int)Dali::Path::Property::POINTS;
37854   jresult = (int)result;
37855   return jresult;
37856 }
37857
37858
37859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37860   int jresult ;
37861   int result;
37862
37863   result = (int)Dali::Path::Property::CONTROL_POINTS;
37864   jresult = (int)result;
37865   return jresult;
37866 }
37867
37868
37869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37870   void * jresult ;
37871   Dali::Path::Property *result = 0 ;
37872
37873   {
37874     try {
37875       result = (Dali::Path::Property *)new Dali::Path::Property();
37876     } catch (std::out_of_range& e) {
37877       {
37878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37879       };
37880     } catch (std::exception& e) {
37881       {
37882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37883       };
37884     } catch (...) {
37885       {
37886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37887       };
37888     }
37889   }
37890   jresult = (void *)result;
37891   return jresult;
37892 }
37893
37894
37895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37896   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37897
37898   arg1 = (Dali::Path::Property *)jarg1;
37899   {
37900     try {
37901       delete arg1;
37902     } catch (std::out_of_range& e) {
37903       {
37904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (std::exception& e) {
37907       {
37908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916 }
37917
37918
37919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37920   void * jresult ;
37921   Dali::Path result;
37922
37923   {
37924     try {
37925       result = Dali::Path::New();
37926     } catch (std::out_of_range& e) {
37927       {
37928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37929       };
37930     } catch (std::exception& e) {
37931       {
37932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37933       };
37934     } catch (...) {
37935       {
37936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37937       };
37938     }
37939   }
37940   jresult = new Dali::Path((const Dali::Path &)result);
37941   return jresult;
37942 }
37943
37944
37945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37946   void * jresult ;
37947   Dali::BaseHandle arg1 ;
37948   Dali::BaseHandle *argp1 ;
37949   Dali::Path result;
37950
37951   argp1 = (Dali::BaseHandle *)jarg1;
37952   if (!argp1) {
37953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37954     return 0;
37955   }
37956   arg1 = *argp1;
37957   {
37958     try {
37959       result = Dali::Path::DownCast(arg1);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37967       };
37968     } catch (...) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37971       };
37972     }
37973   }
37974   jresult = new Dali::Path((const Dali::Path &)result);
37975   return jresult;
37976 }
37977
37978
37979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37980   void * jresult ;
37981   Dali::Path *result = 0 ;
37982
37983   {
37984     try {
37985       result = (Dali::Path *)new Dali::Path();
37986     } catch (std::out_of_range& e) {
37987       {
37988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37989       };
37990     } catch (std::exception& e) {
37991       {
37992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37993       };
37994     } catch (...) {
37995       {
37996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37997       };
37998     }
37999   }
38000   jresult = (void *)result;
38001   return jresult;
38002 }
38003
38004
38005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38006   Dali::Path *arg1 = (Dali::Path *) 0 ;
38007
38008   arg1 = (Dali::Path *)jarg1;
38009   {
38010     try {
38011       delete arg1;
38012     } catch (std::out_of_range& e) {
38013       {
38014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38015       };
38016     } catch (std::exception& e) {
38017       {
38018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38019       };
38020     } catch (...) {
38021       {
38022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38023       };
38024     }
38025   }
38026 }
38027
38028
38029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38030   void * jresult ;
38031   Dali::Path *arg1 = 0 ;
38032   Dali::Path *result = 0 ;
38033
38034   arg1 = (Dali::Path *)jarg1;
38035   if (!arg1) {
38036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38037     return 0;
38038   }
38039   {
38040     try {
38041       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (...) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38053       };
38054     }
38055   }
38056   jresult = (void *)result;
38057   return jresult;
38058 }
38059
38060
38061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38062   void * jresult ;
38063   Dali::Path *arg1 = (Dali::Path *) 0 ;
38064   Dali::Path *arg2 = 0 ;
38065   Dali::Path *result = 0 ;
38066
38067   arg1 = (Dali::Path *)jarg1;
38068   arg2 = (Dali::Path *)jarg2;
38069   if (!arg2) {
38070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38071     return 0;
38072   }
38073   {
38074     try {
38075       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38076     } catch (std::out_of_range& e) {
38077       {
38078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38079       };
38080     } catch (std::exception& e) {
38081       {
38082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38083       };
38084     } catch (...) {
38085       {
38086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38087       };
38088     }
38089   }
38090   jresult = (void *)result;
38091   return jresult;
38092 }
38093
38094
38095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38096   Dali::Path *arg1 = (Dali::Path *) 0 ;
38097   Dali::Vector3 *arg2 = 0 ;
38098
38099   arg1 = (Dali::Path *)jarg1;
38100   arg2 = (Dali::Vector3 *)jarg2;
38101   if (!arg2) {
38102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38103     return ;
38104   }
38105   {
38106     try {
38107       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38108     } catch (std::out_of_range& e) {
38109       {
38110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38111       };
38112     } catch (std::exception& e) {
38113       {
38114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38115       };
38116     } catch (...) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38119       };
38120     }
38121   }
38122 }
38123
38124
38125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38126   Dali::Path *arg1 = (Dali::Path *) 0 ;
38127   Dali::Vector3 *arg2 = 0 ;
38128
38129   arg1 = (Dali::Path *)jarg1;
38130   arg2 = (Dali::Vector3 *)jarg2;
38131   if (!arg2) {
38132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38133     return ;
38134   }
38135   {
38136     try {
38137       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38138     } catch (std::out_of_range& e) {
38139       {
38140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38141       };
38142     } catch (std::exception& e) {
38143       {
38144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38145       };
38146     } catch (...) {
38147       {
38148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38149       };
38150     }
38151   }
38152 }
38153
38154
38155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38156   Dali::Path *arg1 = (Dali::Path *) 0 ;
38157   float arg2 ;
38158
38159   arg1 = (Dali::Path *)jarg1;
38160   arg2 = (float)jarg2;
38161   {
38162     try {
38163       (arg1)->GenerateControlPoints(arg2);
38164     } catch (std::out_of_range& e) {
38165       {
38166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38167       };
38168     } catch (std::exception& e) {
38169       {
38170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38175       };
38176     }
38177   }
38178 }
38179
38180
38181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38182   Dali::Path *arg1 = (Dali::Path *) 0 ;
38183   float arg2 ;
38184   Dali::Vector3 *arg3 = 0 ;
38185   Dali::Vector3 *arg4 = 0 ;
38186
38187   arg1 = (Dali::Path *)jarg1;
38188   arg2 = (float)jarg2;
38189   arg3 = (Dali::Vector3 *)jarg3;
38190   if (!arg3) {
38191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38192     return ;
38193   }
38194   arg4 = (Dali::Vector3 *)jarg4;
38195   if (!arg4) {
38196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38197     return ;
38198   }
38199   {
38200     try {
38201       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38202     } catch (std::out_of_range& e) {
38203       {
38204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38205       };
38206     } catch (std::exception& e) {
38207       {
38208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38209       };
38210     } catch (...) {
38211       {
38212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38213       };
38214     }
38215   }
38216 }
38217
38218
38219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38220   void * jresult ;
38221   Dali::Path *arg1 = (Dali::Path *) 0 ;
38222   size_t arg2 ;
38223   Dali::Vector3 *result = 0 ;
38224
38225   arg1 = (Dali::Path *)jarg1;
38226   arg2 = (size_t)jarg2;
38227   {
38228     try {
38229       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38230     } catch (std::out_of_range& e) {
38231       {
38232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38233       };
38234     } catch (std::exception& e) {
38235       {
38236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (...) {
38239       {
38240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38241       };
38242     }
38243   }
38244   jresult = (void *)result;
38245   return jresult;
38246 }
38247
38248
38249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38250   void * jresult ;
38251   Dali::Path *arg1 = (Dali::Path *) 0 ;
38252   size_t arg2 ;
38253   Dali::Vector3 *result = 0 ;
38254
38255   arg1 = (Dali::Path *)jarg1;
38256   arg2 = (size_t)jarg2;
38257   {
38258     try {
38259       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38260     } catch (std::out_of_range& e) {
38261       {
38262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38263       };
38264     } catch (std::exception& e) {
38265       {
38266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38267       };
38268     } catch (...) {
38269       {
38270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38271       };
38272     }
38273   }
38274   jresult = (void *)result;
38275   return jresult;
38276 }
38277
38278
38279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38280   unsigned long jresult ;
38281   Dali::Path *arg1 = (Dali::Path *) 0 ;
38282   size_t result;
38283
38284   arg1 = (Dali::Path *)jarg1;
38285   {
38286     try {
38287       result = ((Dali::Path const *)arg1)->GetPointCount();
38288     } catch (std::out_of_range& e) {
38289       {
38290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38291       };
38292     } catch (std::exception& e) {
38293       {
38294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38295       };
38296     } catch (...) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38299       };
38300     }
38301   }
38302   jresult = (unsigned long)result;
38303   return jresult;
38304 }
38305
38306
38307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38308   void * jresult ;
38309   float arg1 ;
38310   Dali::TimePeriod *result = 0 ;
38311
38312   arg1 = (float)jarg1;
38313   {
38314     try {
38315       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38316     } catch (std::out_of_range& e) {
38317       {
38318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38319       };
38320     } catch (std::exception& e) {
38321       {
38322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38323       };
38324     } catch (...) {
38325       {
38326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38327       };
38328     }
38329   }
38330   jresult = (void *)result;
38331   return jresult;
38332 }
38333
38334
38335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38336   void * jresult ;
38337   float arg1 ;
38338   float arg2 ;
38339   Dali::TimePeriod *result = 0 ;
38340
38341   arg1 = (float)jarg1;
38342   arg2 = (float)jarg2;
38343   {
38344     try {
38345       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38346     } catch (std::out_of_range& e) {
38347       {
38348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38349       };
38350     } catch (std::exception& e) {
38351       {
38352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38357       };
38358     }
38359   }
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38366   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38367
38368   arg1 = (Dali::TimePeriod *)jarg1;
38369   {
38370     try {
38371       delete arg1;
38372     } catch (std::out_of_range& e) {
38373       {
38374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38375       };
38376     } catch (std::exception& e) {
38377       {
38378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38383       };
38384     }
38385   }
38386 }
38387
38388
38389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38390   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38391   float arg2 ;
38392
38393   arg1 = (Dali::TimePeriod *)jarg1;
38394   arg2 = (float)jarg2;
38395   if (arg1) (arg1)->delaySeconds = arg2;
38396 }
38397
38398
38399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38400   float jresult ;
38401   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38402   float result;
38403
38404   arg1 = (Dali::TimePeriod *)jarg1;
38405   result = (float) ((arg1)->delaySeconds);
38406   jresult = result;
38407   return jresult;
38408 }
38409
38410
38411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38412   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38413   float arg2 ;
38414
38415   arg1 = (Dali::TimePeriod *)jarg1;
38416   arg2 = (float)jarg2;
38417   if (arg1) (arg1)->durationSeconds = arg2;
38418 }
38419
38420
38421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38422   float jresult ;
38423   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38424   float result;
38425
38426   arg1 = (Dali::TimePeriod *)jarg1;
38427   result = (float) ((arg1)->durationSeconds);
38428   jresult = result;
38429   return jresult;
38430 }
38431
38432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38433   int jresult ;
38434   int result;
38435
38436   result = (int)Dali::LinearConstrainer::Property::VALUE;
38437   jresult = (int)result;
38438   return jresult;
38439 }
38440
38441
38442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38443   int jresult ;
38444   int result;
38445
38446   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38447   jresult = (int)result;
38448   return jresult;
38449 }
38450
38451
38452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38453   void * jresult ;
38454   Dali::LinearConstrainer::Property *result = 0 ;
38455
38456   {
38457     try {
38458       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38459     } catch (std::out_of_range& e) {
38460       {
38461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38462       };
38463     } catch (std::exception& e) {
38464       {
38465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38466       };
38467     } catch (...) {
38468       {
38469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38470       };
38471     }
38472   }
38473   jresult = (void *)result;
38474   return jresult;
38475 }
38476
38477
38478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38479   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38480
38481   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38482   {
38483     try {
38484       delete arg1;
38485     } catch (std::out_of_range& e) {
38486       {
38487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38488       };
38489     } catch (std::exception& e) {
38490       {
38491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38492       };
38493     } catch (...) {
38494       {
38495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38496       };
38497     }
38498   }
38499 }
38500
38501
38502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38503   void * jresult ;
38504   Dali::LinearConstrainer result;
38505
38506   {
38507     try {
38508       result = Dali::LinearConstrainer::New();
38509     } catch (std::out_of_range& e) {
38510       {
38511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38512       };
38513     } catch (std::exception& e) {
38514       {
38515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38516       };
38517     } catch (...) {
38518       {
38519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38520       };
38521     }
38522   }
38523   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38524   return jresult;
38525 }
38526
38527
38528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38529   void * jresult ;
38530   Dali::BaseHandle arg1 ;
38531   Dali::BaseHandle *argp1 ;
38532   Dali::LinearConstrainer result;
38533
38534   argp1 = (Dali::BaseHandle *)jarg1;
38535   if (!argp1) {
38536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38537     return 0;
38538   }
38539   arg1 = *argp1;
38540   {
38541     try {
38542       result = Dali::LinearConstrainer::DownCast(arg1);
38543     } catch (std::out_of_range& e) {
38544       {
38545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (std::exception& e) {
38548       {
38549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38558   return jresult;
38559 }
38560
38561
38562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38563   void * jresult ;
38564   Dali::LinearConstrainer *result = 0 ;
38565
38566   {
38567     try {
38568       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583   jresult = (void *)result;
38584   return jresult;
38585 }
38586
38587
38588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38589   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38590
38591   arg1 = (Dali::LinearConstrainer *)jarg1;
38592   {
38593     try {
38594       delete arg1;
38595     } catch (std::out_of_range& e) {
38596       {
38597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38598       };
38599     } catch (std::exception& e) {
38600       {
38601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38602       };
38603     } catch (...) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38606       };
38607     }
38608   }
38609 }
38610
38611
38612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38613   void * jresult ;
38614   Dali::LinearConstrainer *arg1 = 0 ;
38615   Dali::LinearConstrainer *result = 0 ;
38616
38617   arg1 = (Dali::LinearConstrainer *)jarg1;
38618   if (!arg1) {
38619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38620     return 0;
38621   }
38622   {
38623     try {
38624       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38625     } catch (std::out_of_range& e) {
38626       {
38627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38628       };
38629     } catch (std::exception& e) {
38630       {
38631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (...) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38636       };
38637     }
38638   }
38639   jresult = (void *)result;
38640   return jresult;
38641 }
38642
38643
38644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38645   void * jresult ;
38646   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38647   Dali::LinearConstrainer *arg2 = 0 ;
38648   Dali::LinearConstrainer *result = 0 ;
38649
38650   arg1 = (Dali::LinearConstrainer *)jarg1;
38651   arg2 = (Dali::LinearConstrainer *)jarg2;
38652   if (!arg2) {
38653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38654     return 0;
38655   }
38656   {
38657     try {
38658       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38659     } catch (std::out_of_range& e) {
38660       {
38661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38662       };
38663     } catch (std::exception& e) {
38664       {
38665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (...) {
38668       {
38669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38670       };
38671     }
38672   }
38673   jresult = (void *)result;
38674   return jresult;
38675 }
38676
38677
38678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38679   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38680   SwigValueWrapper< Dali::Property > arg2 ;
38681   SwigValueWrapper< Dali::Property > arg3 ;
38682   Dali::Vector2 *arg4 = 0 ;
38683   Dali::Vector2 *arg5 = 0 ;
38684   Dali::Property *argp2 ;
38685   Dali::Property *argp3 ;
38686
38687   arg1 = (Dali::LinearConstrainer *)jarg1;
38688   argp2 = (Dali::Property *)jarg2;
38689   if (!argp2) {
38690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38691     return ;
38692   }
38693   arg2 = *argp2;
38694   argp3 = (Dali::Property *)jarg3;
38695   if (!argp3) {
38696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38697     return ;
38698   }
38699   arg3 = *argp3;
38700   arg4 = (Dali::Vector2 *)jarg4;
38701   if (!arg4) {
38702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38703     return ;
38704   }
38705   arg5 = (Dali::Vector2 *)jarg5;
38706   if (!arg5) {
38707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38708     return ;
38709   }
38710   {
38711     try {
38712       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38713     } catch (std::out_of_range& e) {
38714       {
38715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38716       };
38717     } catch (std::exception& e) {
38718       {
38719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38720       };
38721     } catch (...) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38724       };
38725     }
38726   }
38727 }
38728
38729
38730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38731   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38732   SwigValueWrapper< Dali::Property > arg2 ;
38733   SwigValueWrapper< Dali::Property > arg3 ;
38734   Dali::Vector2 *arg4 = 0 ;
38735   Dali::Property *argp2 ;
38736   Dali::Property *argp3 ;
38737
38738   arg1 = (Dali::LinearConstrainer *)jarg1;
38739   argp2 = (Dali::Property *)jarg2;
38740   if (!argp2) {
38741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38742     return ;
38743   }
38744   arg2 = *argp2;
38745   argp3 = (Dali::Property *)jarg3;
38746   if (!argp3) {
38747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38748     return ;
38749   }
38750   arg3 = *argp3;
38751   arg4 = (Dali::Vector2 *)jarg4;
38752   if (!arg4) {
38753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38754     return ;
38755   }
38756   {
38757     try {
38758       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38759     } catch (std::out_of_range& e) {
38760       {
38761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38762       };
38763     } catch (std::exception& e) {
38764       {
38765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38766       };
38767     } catch (...) {
38768       {
38769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38770       };
38771     }
38772   }
38773 }
38774
38775
38776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38777   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38778   Dali::Handle *arg2 = 0 ;
38779
38780   arg1 = (Dali::LinearConstrainer *)jarg1;
38781   arg2 = (Dali::Handle *)jarg2;
38782   if (!arg2) {
38783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38784     return ;
38785   }
38786   {
38787     try {
38788       (arg1)->Remove(*arg2);
38789     } catch (std::out_of_range& e) {
38790       {
38791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38792       };
38793     } catch (std::exception& e) {
38794       {
38795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38796       };
38797     } catch (...) {
38798       {
38799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38800       };
38801     }
38802   }
38803 }
38804
38805
38806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38807   int jresult ;
38808   int result;
38809
38810   result = (int)Dali::PathConstrainer::Property::FORWARD;
38811   jresult = (int)result;
38812   return jresult;
38813 }
38814
38815
38816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38817   int jresult ;
38818   int result;
38819
38820   result = (int)Dali::PathConstrainer::Property::POINTS;
38821   jresult = (int)result;
38822   return jresult;
38823 }
38824
38825
38826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38827   int jresult ;
38828   int result;
38829
38830   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38831   jresult = (int)result;
38832   return jresult;
38833 }
38834
38835
38836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38837   void * jresult ;
38838   Dali::PathConstrainer::Property *result = 0 ;
38839
38840   {
38841     try {
38842       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38843     } catch (std::out_of_range& e) {
38844       {
38845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (std::exception& e) {
38848       {
38849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857   jresult = (void *)result;
38858   return jresult;
38859 }
38860
38861
38862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38863   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38864
38865   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38866   {
38867     try {
38868       delete arg1;
38869     } catch (std::out_of_range& e) {
38870       {
38871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38872       };
38873     } catch (std::exception& e) {
38874       {
38875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38876       };
38877     } catch (...) {
38878       {
38879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38880       };
38881     }
38882   }
38883 }
38884
38885
38886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38887   void * jresult ;
38888   Dali::PathConstrainer result;
38889
38890   {
38891     try {
38892       result = Dali::PathConstrainer::New();
38893     } catch (std::out_of_range& e) {
38894       {
38895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38896       };
38897     } catch (std::exception& e) {
38898       {
38899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (...) {
38902       {
38903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38904       };
38905     }
38906   }
38907   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38908   return jresult;
38909 }
38910
38911
38912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38913   void * jresult ;
38914   Dali::BaseHandle arg1 ;
38915   Dali::BaseHandle *argp1 ;
38916   Dali::PathConstrainer result;
38917
38918   argp1 = (Dali::BaseHandle *)jarg1;
38919   if (!argp1) {
38920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38921     return 0;
38922   }
38923   arg1 = *argp1;
38924   {
38925     try {
38926       result = Dali::PathConstrainer::DownCast(arg1);
38927     } catch (std::out_of_range& e) {
38928       {
38929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38930       };
38931     } catch (std::exception& e) {
38932       {
38933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38934       };
38935     } catch (...) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38938       };
38939     }
38940   }
38941   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38942   return jresult;
38943 }
38944
38945
38946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38947   void * jresult ;
38948   Dali::PathConstrainer *result = 0 ;
38949
38950   {
38951     try {
38952       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38953     } catch (std::out_of_range& e) {
38954       {
38955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38956       };
38957     } catch (std::exception& e) {
38958       {
38959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38960       };
38961     } catch (...) {
38962       {
38963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38964       };
38965     }
38966   }
38967   jresult = (void *)result;
38968   return jresult;
38969 }
38970
38971
38972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38973   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38974
38975   arg1 = (Dali::PathConstrainer *)jarg1;
38976   {
38977     try {
38978       delete arg1;
38979     } catch (std::out_of_range& e) {
38980       {
38981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38982       };
38983     } catch (std::exception& e) {
38984       {
38985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38990       };
38991     }
38992   }
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38997   void * jresult ;
38998   Dali::PathConstrainer *arg1 = 0 ;
38999   Dali::PathConstrainer *result = 0 ;
39000
39001   arg1 = (Dali::PathConstrainer *)jarg1;
39002   if (!arg1) {
39003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39004     return 0;
39005   }
39006   {
39007     try {
39008       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023   jresult = (void *)result;
39024   return jresult;
39025 }
39026
39027
39028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39029   void * jresult ;
39030   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39031   Dali::PathConstrainer *arg2 = 0 ;
39032   Dali::PathConstrainer *result = 0 ;
39033
39034   arg1 = (Dali::PathConstrainer *)jarg1;
39035   arg2 = (Dali::PathConstrainer *)jarg2;
39036   if (!arg2) {
39037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39038     return 0;
39039   }
39040   {
39041     try {
39042       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39043     } catch (std::out_of_range& e) {
39044       {
39045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39046       };
39047     } catch (std::exception& e) {
39048       {
39049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39050       };
39051     } catch (...) {
39052       {
39053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39054       };
39055     }
39056   }
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39063   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39064   SwigValueWrapper< Dali::Property > arg2 ;
39065   SwigValueWrapper< Dali::Property > arg3 ;
39066   Dali::Vector2 *arg4 = 0 ;
39067   Dali::Vector2 *arg5 = 0 ;
39068   Dali::Property *argp2 ;
39069   Dali::Property *argp3 ;
39070
39071   arg1 = (Dali::PathConstrainer *)jarg1;
39072   argp2 = (Dali::Property *)jarg2;
39073   if (!argp2) {
39074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39075     return ;
39076   }
39077   arg2 = *argp2;
39078   argp3 = (Dali::Property *)jarg3;
39079   if (!argp3) {
39080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39081     return ;
39082   }
39083   arg3 = *argp3;
39084   arg4 = (Dali::Vector2 *)jarg4;
39085   if (!arg4) {
39086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39087     return ;
39088   }
39089   arg5 = (Dali::Vector2 *)jarg5;
39090   if (!arg5) {
39091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39092     return ;
39093   }
39094   {
39095     try {
39096       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39097     } catch (std::out_of_range& e) {
39098       {
39099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39100       };
39101     } catch (std::exception& e) {
39102       {
39103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39104       };
39105     } catch (...) {
39106       {
39107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39108       };
39109     }
39110   }
39111 }
39112
39113
39114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39115   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39116   SwigValueWrapper< Dali::Property > arg2 ;
39117   SwigValueWrapper< Dali::Property > arg3 ;
39118   Dali::Vector2 *arg4 = 0 ;
39119   Dali::Property *argp2 ;
39120   Dali::Property *argp3 ;
39121
39122   arg1 = (Dali::PathConstrainer *)jarg1;
39123   argp2 = (Dali::Property *)jarg2;
39124   if (!argp2) {
39125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39126     return ;
39127   }
39128   arg2 = *argp2;
39129   argp3 = (Dali::Property *)jarg3;
39130   if (!argp3) {
39131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39132     return ;
39133   }
39134   arg3 = *argp3;
39135   arg4 = (Dali::Vector2 *)jarg4;
39136   if (!arg4) {
39137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39138     return ;
39139   }
39140   {
39141     try {
39142       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39143     } catch (std::out_of_range& e) {
39144       {
39145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (std::exception& e) {
39148       {
39149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39154       };
39155     }
39156   }
39157 }
39158
39159
39160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39161   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39162   Dali::Handle *arg2 = 0 ;
39163
39164   arg1 = (Dali::PathConstrainer *)jarg1;
39165   arg2 = (Dali::Handle *)jarg2;
39166   if (!arg2) {
39167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39168     return ;
39169   }
39170   {
39171     try {
39172       (arg1)->Remove(*arg2);
39173     } catch (std::out_of_range& e) {
39174       {
39175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39176       };
39177     } catch (std::exception& e) {
39178       {
39179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39180       };
39181     } catch (...) {
39182       {
39183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39184       };
39185     }
39186   }
39187 }
39188
39189
39190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39191   int jresult ;
39192   Dali::FittingMode::Type result;
39193
39194   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39195   jresult = (int)result;
39196   return jresult;
39197 }
39198
39199
39200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39201   int jresult ;
39202   Dali::SamplingMode::Type result;
39203
39204   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39205   jresult = (int)result;
39206   return jresult;
39207 }
39208
39209
39210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39211   void * jresult ;
39212   Dali::BufferImage *result = 0 ;
39213
39214   {
39215     try {
39216       result = (Dali::BufferImage *)new Dali::BufferImage();
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (...) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39228       };
39229     }
39230   }
39231   jresult = (void *)result;
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39237   void * jresult ;
39238   unsigned int arg1 ;
39239   unsigned int arg2 ;
39240   Dali::Pixel::Format arg3 ;
39241   Dali::BufferImage result;
39242
39243   arg1 = (unsigned int)jarg1;
39244   arg2 = (unsigned int)jarg2;
39245   arg3 = (Dali::Pixel::Format)jarg3;
39246   {
39247     try {
39248       result = Dali::BufferImage::New(arg1,arg2,arg3);
39249     } catch (std::out_of_range& e) {
39250       {
39251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39252       };
39253     } catch (std::exception& e) {
39254       {
39255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39256       };
39257     } catch (...) {
39258       {
39259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39260       };
39261     }
39262   }
39263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39264   return jresult;
39265 }
39266
39267
39268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39269   void * jresult ;
39270   unsigned int arg1 ;
39271   unsigned int arg2 ;
39272   Dali::BufferImage result;
39273
39274   arg1 = (unsigned int)jarg1;
39275   arg2 = (unsigned int)jarg2;
39276   {
39277     try {
39278       result = Dali::BufferImage::New(arg1,arg2);
39279     } catch (std::out_of_range& e) {
39280       {
39281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39282       };
39283     } catch (std::exception& e) {
39284       {
39285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39286       };
39287     } catch (...) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39290       };
39291     }
39292   }
39293   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39294   return jresult;
39295 }
39296
39297
39298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39299   void * jresult ;
39300   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39301   unsigned int arg2 ;
39302   unsigned int arg3 ;
39303   Dali::Pixel::Format arg4 ;
39304   unsigned int arg5 ;
39305   Dali::BufferImage result;
39306
39307   arg1 = jarg1;
39308   arg2 = (unsigned int)jarg2;
39309   arg3 = (unsigned int)jarg3;
39310   arg4 = (Dali::Pixel::Format)jarg4;
39311   arg5 = (unsigned int)jarg5;
39312   {
39313     try {
39314       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39315     } catch (std::out_of_range& e) {
39316       {
39317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39318       };
39319     } catch (std::exception& e) {
39320       {
39321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (...) {
39324       {
39325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39326       };
39327     }
39328   }
39329   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39330
39331
39332   return jresult;
39333 }
39334
39335
39336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39337   void * jresult ;
39338   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39339   unsigned int arg2 ;
39340   unsigned int arg3 ;
39341   Dali::Pixel::Format arg4 ;
39342   Dali::BufferImage result;
39343
39344   arg1 = jarg1;
39345   arg2 = (unsigned int)jarg2;
39346   arg3 = (unsigned int)jarg3;
39347   arg4 = (Dali::Pixel::Format)jarg4;
39348   {
39349     try {
39350       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39351     } catch (std::out_of_range& e) {
39352       {
39353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39354       };
39355     } catch (std::exception& e) {
39356       {
39357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39358       };
39359     } catch (...) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39362       };
39363     }
39364   }
39365   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39366
39367
39368   return jresult;
39369 }
39370
39371
39372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39373   void * jresult ;
39374   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39375   unsigned int arg2 ;
39376   unsigned int arg3 ;
39377   Dali::BufferImage result;
39378
39379   arg1 = jarg1;
39380   arg2 = (unsigned int)jarg2;
39381   arg3 = (unsigned int)jarg3;
39382   {
39383     try {
39384       result = Dali::BufferImage::New(arg1,arg2,arg3);
39385     } catch (std::out_of_range& e) {
39386       {
39387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39388       };
39389     } catch (std::exception& e) {
39390       {
39391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39392       };
39393     } catch (...) {
39394       {
39395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39396       };
39397     }
39398   }
39399   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39400
39401
39402   return jresult;
39403 }
39404
39405
39406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39407   void * jresult ;
39408   Dali::BaseHandle arg1 ;
39409   Dali::BaseHandle *argp1 ;
39410   Dali::BufferImage result;
39411
39412   argp1 = (Dali::BaseHandle *)jarg1;
39413   if (!argp1) {
39414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39415     return 0;
39416   }
39417   arg1 = *argp1;
39418   {
39419     try {
39420       result = Dali::BufferImage::DownCast(arg1);
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39432       };
39433     }
39434   }
39435   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39436   return jresult;
39437 }
39438
39439
39440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39441   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39442
39443   arg1 = (Dali::BufferImage *)jarg1;
39444   {
39445     try {
39446       delete arg1;
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39454       };
39455     } catch (...) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39458       };
39459     }
39460   }
39461 }
39462
39463
39464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39465   void * jresult ;
39466   Dali::BufferImage *arg1 = 0 ;
39467   Dali::BufferImage *result = 0 ;
39468
39469   arg1 = (Dali::BufferImage *)jarg1;
39470   if (!arg1) {
39471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39472     return 0;
39473   }
39474   {
39475     try {
39476       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39477     } catch (std::out_of_range& e) {
39478       {
39479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39480       };
39481     } catch (std::exception& e) {
39482       {
39483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39484       };
39485     } catch (...) {
39486       {
39487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39488       };
39489     }
39490   }
39491   jresult = (void *)result;
39492   return jresult;
39493 }
39494
39495
39496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39497   void * jresult ;
39498   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39499   Dali::BufferImage *arg2 = 0 ;
39500   Dali::BufferImage *result = 0 ;
39501
39502   arg1 = (Dali::BufferImage *)jarg1;
39503   arg2 = (Dali::BufferImage *)jarg2;
39504   if (!arg2) {
39505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39506     return 0;
39507   }
39508   {
39509     try {
39510       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39511     } catch (std::out_of_range& e) {
39512       {
39513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39514       };
39515     } catch (std::exception& e) {
39516       {
39517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39518       };
39519     } catch (...) {
39520       {
39521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39522       };
39523     }
39524   }
39525   jresult = (void *)result;
39526   return jresult;
39527 }
39528
39529
39530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39531   void * jresult ;
39532   Dali::BufferImage result;
39533
39534   {
39535     try {
39536       result = Dali::BufferImage::WHITE();
39537     } catch (std::out_of_range& e) {
39538       {
39539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39540       };
39541     } catch (std::exception& e) {
39542       {
39543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39544       };
39545     } catch (...) {
39546       {
39547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39548       };
39549     }
39550   }
39551   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39552   return jresult;
39553 }
39554
39555
39556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39557   void * jresult ;
39558   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39559   Dali::PixelBuffer *result = 0 ;
39560
39561   arg1 = (Dali::BufferImage *)jarg1;
39562   {
39563     try {
39564       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39565     } catch (std::out_of_range& e) {
39566       {
39567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39568       };
39569     } catch (std::exception& e) {
39570       {
39571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39572       };
39573     } catch (...) {
39574       {
39575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39576       };
39577     }
39578   }
39579   jresult = (void *)result;
39580   return jresult;
39581 }
39582
39583
39584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39585   unsigned int jresult ;
39586   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39587   unsigned int result;
39588
39589   arg1 = (Dali::BufferImage *)jarg1;
39590   {
39591     try {
39592       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39593     } catch (std::out_of_range& e) {
39594       {
39595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39596       };
39597     } catch (std::exception& e) {
39598       {
39599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39600       };
39601     } catch (...) {
39602       {
39603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39604       };
39605     }
39606   }
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39613   unsigned int jresult ;
39614   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39615   unsigned int result;
39616
39617   arg1 = (Dali::BufferImage *)jarg1;
39618   {
39619     try {
39620       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39632       };
39633     }
39634   }
39635   jresult = result;
39636   return jresult;
39637 }
39638
39639
39640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39641   int jresult ;
39642   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39643   Dali::Pixel::Format result;
39644
39645   arg1 = (Dali::BufferImage *)jarg1;
39646   {
39647     try {
39648       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39649     } catch (std::out_of_range& e) {
39650       {
39651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39652       };
39653     } catch (std::exception& e) {
39654       {
39655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (...) {
39658       {
39659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39660       };
39661     }
39662   }
39663   jresult = (int)result;
39664   return jresult;
39665 }
39666
39667
39668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39669   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39670
39671   arg1 = (Dali::BufferImage *)jarg1;
39672   {
39673     try {
39674       (arg1)->Update();
39675     } catch (std::out_of_range& e) {
39676       {
39677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39678       };
39679     } catch (std::exception& e) {
39680       {
39681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39682       };
39683     } catch (...) {
39684       {
39685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39686       };
39687     }
39688   }
39689 }
39690
39691
39692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39693   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39694   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39695   Dali::RectArea *argp2 ;
39696
39697   arg1 = (Dali::BufferImage *)jarg1;
39698   argp2 = (Dali::RectArea *)jarg2;
39699   if (!argp2) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39701     return ;
39702   }
39703   arg2 = *argp2;
39704   {
39705     try {
39706       (arg1)->Update(arg2);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39725   unsigned int jresult ;
39726   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39727   bool result;
39728
39729   arg1 = (Dali::BufferImage *)jarg1;
39730   {
39731     try {
39732       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39733     } catch (std::out_of_range& e) {
39734       {
39735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39736       };
39737     } catch (std::exception& e) {
39738       {
39739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (...) {
39742       {
39743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39744       };
39745     }
39746   }
39747   jresult = result;
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39753   void * jresult ;
39754   Dali::EncodedBufferImage *result = 0 ;
39755
39756   {
39757     try {
39758       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39759     } catch (std::out_of_range& e) {
39760       {
39761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39762       };
39763     } catch (std::exception& e) {
39764       {
39765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39766       };
39767     } catch (...) {
39768       {
39769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39770       };
39771     }
39772   }
39773   jresult = (void *)result;
39774   return jresult;
39775 }
39776
39777
39778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39779   void * jresult ;
39780   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39781   std::size_t arg2 ;
39782   Dali::EncodedBufferImage result;
39783
39784   arg1 = (uint8_t *)jarg1;
39785   arg2 = (std::size_t)jarg2;
39786   {
39787     try {
39788       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39789     } catch (std::out_of_range& e) {
39790       {
39791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39792       };
39793     } catch (std::exception& e) {
39794       {
39795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39796       };
39797     } catch (...) {
39798       {
39799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39800       };
39801     }
39802   }
39803   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39804   return jresult;
39805 }
39806
39807
39808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39809   void * jresult ;
39810   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39811   std::size_t arg2 ;
39812   Dali::ImageDimensions arg3 ;
39813   Dali::FittingMode::Type arg4 ;
39814   Dali::SamplingMode::Type arg5 ;
39815   bool arg6 ;
39816   Dali::ImageDimensions *argp3 ;
39817   Dali::EncodedBufferImage result;
39818
39819   arg1 = (uint8_t *)jarg1;
39820   arg2 = (std::size_t)jarg2;
39821   argp3 = (Dali::ImageDimensions *)jarg3;
39822   if (!argp3) {
39823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39824     return 0;
39825   }
39826   arg3 = *argp3;
39827   arg4 = (Dali::FittingMode::Type)jarg4;
39828   arg5 = (Dali::SamplingMode::Type)jarg5;
39829   arg6 = jarg6 ? true : false;
39830   {
39831     try {
39832       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39833     } catch (std::out_of_range& e) {
39834       {
39835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39836       };
39837     } catch (std::exception& e) {
39838       {
39839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (...) {
39842       {
39843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39844       };
39845     }
39846   }
39847   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39848   return jresult;
39849 }
39850
39851
39852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39853   void * jresult ;
39854   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39855   std::size_t arg2 ;
39856   Dali::ImageDimensions arg3 ;
39857   Dali::FittingMode::Type arg4 ;
39858   Dali::SamplingMode::Type arg5 ;
39859   Dali::ImageDimensions *argp3 ;
39860   Dali::EncodedBufferImage result;
39861
39862   arg1 = (uint8_t *)jarg1;
39863   arg2 = (std::size_t)jarg2;
39864   argp3 = (Dali::ImageDimensions *)jarg3;
39865   if (!argp3) {
39866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39867     return 0;
39868   }
39869   arg3 = *argp3;
39870   arg4 = (Dali::FittingMode::Type)jarg4;
39871   arg5 = (Dali::SamplingMode::Type)jarg5;
39872   {
39873     try {
39874       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39875     } catch (std::out_of_range& e) {
39876       {
39877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39878       };
39879     } catch (std::exception& e) {
39880       {
39881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39882       };
39883     } catch (...) {
39884       {
39885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39886       };
39887     }
39888   }
39889   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39895   void * jresult ;
39896   Dali::BaseHandle arg1 ;
39897   Dali::BaseHandle *argp1 ;
39898   Dali::EncodedBufferImage result;
39899
39900   argp1 = (Dali::BaseHandle *)jarg1;
39901   if (!argp1) {
39902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39903     return 0;
39904   }
39905   arg1 = *argp1;
39906   {
39907     try {
39908       result = Dali::EncodedBufferImage::DownCast(arg1);
39909     } catch (std::out_of_range& e) {
39910       {
39911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39912       };
39913     } catch (std::exception& e) {
39914       {
39915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39916       };
39917     } catch (...) {
39918       {
39919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39920       };
39921     }
39922   }
39923   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39924   return jresult;
39925 }
39926
39927
39928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39929   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39930
39931   arg1 = (Dali::EncodedBufferImage *)jarg1;
39932   {
39933     try {
39934       delete arg1;
39935     } catch (std::out_of_range& e) {
39936       {
39937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39938       };
39939     } catch (std::exception& e) {
39940       {
39941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39942       };
39943     } catch (...) {
39944       {
39945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39946       };
39947     }
39948   }
39949 }
39950
39951
39952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39953   void * jresult ;
39954   Dali::EncodedBufferImage *arg1 = 0 ;
39955   Dali::EncodedBufferImage *result = 0 ;
39956
39957   arg1 = (Dali::EncodedBufferImage *)jarg1;
39958   if (!arg1) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39960     return 0;
39961   }
39962   {
39963     try {
39964       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39965     } catch (std::out_of_range& e) {
39966       {
39967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (std::exception& e) {
39970       {
39971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39972       };
39973     } catch (...) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39976       };
39977     }
39978   }
39979   jresult = (void *)result;
39980   return jresult;
39981 }
39982
39983
39984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39985   void * jresult ;
39986   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39987   Dali::EncodedBufferImage *arg2 = 0 ;
39988   Dali::EncodedBufferImage *result = 0 ;
39989
39990   arg1 = (Dali::EncodedBufferImage *)jarg1;
39991   arg2 = (Dali::EncodedBufferImage *)jarg2;
39992   if (!arg2) {
39993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39994     return 0;
39995   }
39996   {
39997     try {
39998       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39999     } catch (std::out_of_range& e) {
40000       {
40001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40002       };
40003     } catch (std::exception& e) {
40004       {
40005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40006       };
40007     } catch (...) {
40008       {
40009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40010       };
40011     }
40012   }
40013   jresult = (void *)result;
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40019   void * jresult ;
40020   Dali::NativeImage *result = 0 ;
40021
40022   {
40023     try {
40024       result = (Dali::NativeImage *)new Dali::NativeImage();
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40032       };
40033     } catch (...) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40036       };
40037     }
40038   }
40039   jresult = (void *)result;
40040   return jresult;
40041 }
40042
40043
40044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40045   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40046
40047   arg1 = (Dali::NativeImage *)jarg1;
40048   {
40049     try {
40050       delete arg1;
40051     } catch (std::out_of_range& e) {
40052       {
40053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40054       };
40055     } catch (std::exception& e) {
40056       {
40057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40058       };
40059     } catch (...) {
40060       {
40061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40062       };
40063     }
40064   }
40065 }
40066
40067
40068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40069   void * jresult ;
40070   Dali::NativeImage *arg1 = 0 ;
40071   Dali::NativeImage *result = 0 ;
40072
40073   arg1 = (Dali::NativeImage *)jarg1;
40074   if (!arg1) {
40075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40076     return 0;
40077   }
40078   {
40079     try {
40080       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40081     } catch (std::out_of_range& e) {
40082       {
40083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40084       };
40085     } catch (std::exception& e) {
40086       {
40087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40088       };
40089     } catch (...) {
40090       {
40091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40092       };
40093     }
40094   }
40095   jresult = (void *)result;
40096   return jresult;
40097 }
40098
40099
40100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40101   void * jresult ;
40102   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40103   Dali::NativeImage *arg2 = 0 ;
40104   Dali::NativeImage *result = 0 ;
40105
40106   arg1 = (Dali::NativeImage *)jarg1;
40107   arg2 = (Dali::NativeImage *)jarg2;
40108   if (!arg2) {
40109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40110     return 0;
40111   }
40112   {
40113     try {
40114       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (...) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40126       };
40127     }
40128   }
40129   jresult = (void *)result;
40130   return jresult;
40131 }
40132
40133
40134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40135   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40136
40137   arg1 = (Dali::NativeImage *)jarg1;
40138   {
40139     try {
40140       (arg1)->CreateGlTexture();
40141     } catch (std::out_of_range& e) {
40142       {
40143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40144       };
40145     } catch (std::exception& e) {
40146       {
40147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40148       };
40149     } catch (...) {
40150       {
40151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40152       };
40153     }
40154   }
40155 }
40156
40157
40158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40159   void * jresult ;
40160   NativeImageInterface *arg1 = 0 ;
40161   Dali::NativeImage result;
40162
40163   arg1 = (NativeImageInterface *)jarg1;
40164   if (!arg1) {
40165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40166     return 0;
40167   }
40168   {
40169     try {
40170       result = Dali::NativeImage::New(*arg1);
40171     } catch (std::out_of_range& e) {
40172       {
40173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40174       };
40175     } catch (std::exception& e) {
40176       {
40177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40178       };
40179     } catch (...) {
40180       {
40181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40182       };
40183     }
40184   }
40185   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40186   return jresult;
40187 }
40188
40189
40190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40191   void * jresult ;
40192   Dali::BaseHandle arg1 ;
40193   Dali::BaseHandle *argp1 ;
40194   Dali::NativeImage result;
40195
40196   argp1 = (Dali::BaseHandle *)jarg1;
40197   if (!argp1) {
40198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40199     return 0;
40200   }
40201   arg1 = *argp1;
40202   {
40203     try {
40204       result = Dali::NativeImage::DownCast(arg1);
40205     } catch (std::out_of_range& e) {
40206       {
40207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40208       };
40209     } catch (std::exception& e) {
40210       {
40211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40212       };
40213     } catch (...) {
40214       {
40215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40216       };
40217     }
40218   }
40219   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40220   return jresult;
40221 }
40222
40223
40224 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40225   char * jresult ;
40226   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40227   char *result = 0 ;
40228
40229   arg1 = (Dali::NativeImage *)jarg1;
40230   {
40231     try {
40232       result = (char *)(arg1)->GetCustomFragmentPreFix();
40233     } catch (std::out_of_range& e) {
40234       {
40235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40236       };
40237     } catch (std::exception& e) {
40238       {
40239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40240       };
40241     } catch (...) {
40242       {
40243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40244       };
40245     }
40246   }
40247   jresult = SWIG_csharp_string_callback((const char *)result);
40248   return jresult;
40249 }
40250
40251
40252 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40253   char * jresult ;
40254   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40255   char *result = 0 ;
40256
40257   arg1 = (Dali::NativeImage *)jarg1;
40258   {
40259     try {
40260       result = (char *)(arg1)->GetCustomSamplerTypename();
40261     } catch (std::out_of_range& e) {
40262       {
40263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40264       };
40265     } catch (std::exception& e) {
40266       {
40267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40272       };
40273     }
40274   }
40275   jresult = SWIG_csharp_string_callback((const char *)result);
40276   return jresult;
40277 }
40278
40279
40280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40281   unsigned int jresult ;
40282   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40283   bool result;
40284
40285   arg1 = (Dali::NativeImageInterface *)jarg1;
40286   {
40287     try {
40288       result = (bool)(arg1)->GlExtensionCreate();
40289     } catch (std::out_of_range& e) {
40290       {
40291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40292       };
40293     } catch (std::exception& e) {
40294       {
40295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40296       };
40297     } catch (...) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40300       };
40301     }
40302   }
40303   jresult = result;
40304   return jresult;
40305 }
40306
40307
40308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40309   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40310
40311   arg1 = (Dali::NativeImageInterface *)jarg1;
40312   {
40313     try {
40314       (arg1)->GlExtensionDestroy();
40315     } catch (std::out_of_range& e) {
40316       {
40317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40318       };
40319     } catch (std::exception& e) {
40320       {
40321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40322       };
40323     } catch (...) {
40324       {
40325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40326       };
40327     }
40328   }
40329 }
40330
40331
40332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40333   unsigned int jresult ;
40334   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40335   unsigned int result;
40336
40337   arg1 = (Dali::NativeImageInterface *)jarg1;
40338   {
40339     try {
40340       result = (unsigned int)(arg1)->TargetTexture();
40341     } catch (std::out_of_range& e) {
40342       {
40343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40344       };
40345     } catch (std::exception& e) {
40346       {
40347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40348       };
40349     } catch (...) {
40350       {
40351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40352       };
40353     }
40354   }
40355   jresult = result;
40356   return jresult;
40357 }
40358
40359
40360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40361   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40362
40363   arg1 = (Dali::NativeImageInterface *)jarg1;
40364   {
40365     try {
40366       (arg1)->PrepareTexture();
40367     } catch (std::out_of_range& e) {
40368       {
40369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40370       };
40371     } catch (std::exception& e) {
40372       {
40373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40374       };
40375     } catch (...) {
40376       {
40377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40378       };
40379     }
40380   }
40381 }
40382
40383
40384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40385   unsigned int jresult ;
40386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40387   unsigned int result;
40388
40389   arg1 = (Dali::NativeImageInterface *)jarg1;
40390   {
40391     try {
40392       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (...) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40404       };
40405     }
40406   }
40407   jresult = result;
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40413   unsigned int jresult ;
40414   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40415   unsigned int result;
40416
40417   arg1 = (Dali::NativeImageInterface *)jarg1;
40418   {
40419     try {
40420       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40421     } catch (std::out_of_range& e) {
40422       {
40423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40424       };
40425     } catch (std::exception& e) {
40426       {
40427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40428       };
40429     } catch (...) {
40430       {
40431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40432       };
40433     }
40434   }
40435   jresult = result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40441   unsigned int jresult ;
40442   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40443   bool result;
40444
40445   arg1 = (Dali::NativeImageInterface *)jarg1;
40446   {
40447     try {
40448       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40449     } catch (std::out_of_range& e) {
40450       {
40451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40452       };
40453     } catch (std::exception& e) {
40454       {
40455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40456       };
40457     } catch (...) {
40458       {
40459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40460       };
40461     }
40462   }
40463   jresult = result;
40464   return jresult;
40465 }
40466
40467
40468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40469   void * jresult ;
40470   std::string *arg1 = 0 ;
40471   Dali::ImageDimensions result;
40472
40473   if (!jarg1) {
40474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40475     return 0;
40476   }
40477   std::string arg1_str(jarg1);
40478   arg1 = &arg1_str;
40479   {
40480     try {
40481       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40482     } catch (std::out_of_range& e) {
40483       {
40484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40485       };
40486     } catch (std::exception& e) {
40487       {
40488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40489       };
40490     } catch (...) {
40491       {
40492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40493       };
40494     }
40495   }
40496   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40497
40498   //argout typemap for const std::string&
40499
40500   return jresult;
40501 }
40502
40503
40504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40505   void * jresult ;
40506   Dali::ResourceImage *result = 0 ;
40507
40508   {
40509     try {
40510       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40511     } catch (std::out_of_range& e) {
40512       {
40513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40514       };
40515     } catch (std::exception& e) {
40516       {
40517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40518       };
40519     } catch (...) {
40520       {
40521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40522       };
40523     }
40524   }
40525   jresult = (void *)result;
40526   return jresult;
40527 }
40528
40529
40530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40531   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40532
40533   arg1 = (Dali::ResourceImage *)jarg1;
40534   {
40535     try {
40536       delete arg1;
40537     } catch (std::out_of_range& e) {
40538       {
40539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40540       };
40541     } catch (std::exception& e) {
40542       {
40543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40544       };
40545     } catch (...) {
40546       {
40547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40548       };
40549     }
40550   }
40551 }
40552
40553
40554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40555   void * jresult ;
40556   Dali::ResourceImage *arg1 = 0 ;
40557   Dali::ResourceImage *result = 0 ;
40558
40559   arg1 = (Dali::ResourceImage *)jarg1;
40560   if (!arg1) {
40561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40562     return 0;
40563   }
40564   {
40565     try {
40566       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581   jresult = (void *)result;
40582   return jresult;
40583 }
40584
40585
40586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40587   void * jresult ;
40588   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40589   Dali::ResourceImage *arg2 = 0 ;
40590   Dali::ResourceImage *result = 0 ;
40591
40592   arg1 = (Dali::ResourceImage *)jarg1;
40593   arg2 = (Dali::ResourceImage *)jarg2;
40594   if (!arg2) {
40595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40596     return 0;
40597   }
40598   {
40599     try {
40600       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40601     } catch (std::out_of_range& e) {
40602       {
40603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40604       };
40605     } catch (std::exception& e) {
40606       {
40607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40608       };
40609     } catch (...) {
40610       {
40611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40612       };
40613     }
40614   }
40615   jresult = (void *)result;
40616   return jresult;
40617 }
40618
40619
40620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40621   void * jresult ;
40622   std::string *arg1 = 0 ;
40623   bool arg2 ;
40624   Dali::ResourceImage result;
40625
40626   if (!jarg1) {
40627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40628     return 0;
40629   }
40630   std::string arg1_str(jarg1);
40631   arg1 = &arg1_str;
40632   arg2 = jarg2 ? true : false;
40633   {
40634     try {
40635       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40643       };
40644     } catch (...) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40647       };
40648     }
40649   }
40650   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40651
40652   //argout typemap for const std::string&
40653
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40659   void * jresult ;
40660   std::string *arg1 = 0 ;
40661   Dali::ResourceImage result;
40662
40663   if (!jarg1) {
40664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40665     return 0;
40666   }
40667   std::string arg1_str(jarg1);
40668   arg1 = &arg1_str;
40669   {
40670     try {
40671       result = Dali::ResourceImage::New((std::string const &)*arg1);
40672     } catch (std::out_of_range& e) {
40673       {
40674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (std::exception& e) {
40677       {
40678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40679       };
40680     } catch (...) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40683       };
40684     }
40685   }
40686   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40687
40688   //argout typemap for const std::string&
40689
40690   return jresult;
40691 }
40692
40693
40694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40695   void * jresult ;
40696   std::string *arg1 = 0 ;
40697   Dali::ImageDimensions arg2 ;
40698   Dali::FittingMode::Type arg3 ;
40699   Dali::SamplingMode::Type arg4 ;
40700   bool arg5 ;
40701   Dali::ImageDimensions *argp2 ;
40702   Dali::ResourceImage result;
40703
40704   if (!jarg1) {
40705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40706     return 0;
40707   }
40708   std::string arg1_str(jarg1);
40709   arg1 = &arg1_str;
40710   argp2 = (Dali::ImageDimensions *)jarg2;
40711   if (!argp2) {
40712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40713     return 0;
40714   }
40715   arg2 = *argp2;
40716   arg3 = (Dali::FittingMode::Type)jarg3;
40717   arg4 = (Dali::SamplingMode::Type)jarg4;
40718   arg5 = jarg5 ? true : false;
40719   {
40720     try {
40721       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40722     } catch (std::out_of_range& e) {
40723       {
40724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40725       };
40726     } catch (std::exception& e) {
40727       {
40728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40729       };
40730     } catch (...) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40733       };
40734     }
40735   }
40736   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40737
40738   //argout typemap for const std::string&
40739
40740   return jresult;
40741 }
40742
40743
40744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40745   void * jresult ;
40746   std::string *arg1 = 0 ;
40747   Dali::ImageDimensions arg2 ;
40748   Dali::FittingMode::Type arg3 ;
40749   Dali::SamplingMode::Type arg4 ;
40750   Dali::ImageDimensions *argp2 ;
40751   Dali::ResourceImage result;
40752
40753   if (!jarg1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40755     return 0;
40756   }
40757   std::string arg1_str(jarg1);
40758   arg1 = &arg1_str;
40759   argp2 = (Dali::ImageDimensions *)jarg2;
40760   if (!argp2) {
40761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40762     return 0;
40763   }
40764   arg2 = *argp2;
40765   arg3 = (Dali::FittingMode::Type)jarg3;
40766   arg4 = (Dali::SamplingMode::Type)jarg4;
40767   {
40768     try {
40769       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40770     } catch (std::out_of_range& e) {
40771       {
40772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40773       };
40774     } catch (std::exception& e) {
40775       {
40776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40781       };
40782     }
40783   }
40784   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40785
40786   //argout typemap for const std::string&
40787
40788   return jresult;
40789 }
40790
40791
40792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40793   void * jresult ;
40794   std::string *arg1 = 0 ;
40795   Dali::ImageDimensions arg2 ;
40796   Dali::FittingMode::Type arg3 ;
40797   Dali::ImageDimensions *argp2 ;
40798   Dali::ResourceImage result;
40799
40800   if (!jarg1) {
40801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40802     return 0;
40803   }
40804   std::string arg1_str(jarg1);
40805   arg1 = &arg1_str;
40806   argp2 = (Dali::ImageDimensions *)jarg2;
40807   if (!argp2) {
40808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40809     return 0;
40810   }
40811   arg2 = *argp2;
40812   arg3 = (Dali::FittingMode::Type)jarg3;
40813   {
40814     try {
40815       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40816     } catch (std::out_of_range& e) {
40817       {
40818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40819       };
40820     } catch (std::exception& e) {
40821       {
40822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40823       };
40824     } catch (...) {
40825       {
40826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40827       };
40828     }
40829   }
40830   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40831
40832   //argout typemap for const std::string&
40833
40834   return jresult;
40835 }
40836
40837
40838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40839   void * jresult ;
40840   std::string *arg1 = 0 ;
40841   Dali::ImageDimensions arg2 ;
40842   Dali::ImageDimensions *argp2 ;
40843   Dali::ResourceImage result;
40844
40845   if (!jarg1) {
40846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40847     return 0;
40848   }
40849   std::string arg1_str(jarg1);
40850   arg1 = &arg1_str;
40851   argp2 = (Dali::ImageDimensions *)jarg2;
40852   if (!argp2) {
40853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40854     return 0;
40855   }
40856   arg2 = *argp2;
40857   {
40858     try {
40859       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40860     } catch (std::out_of_range& e) {
40861       {
40862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40863       };
40864     } catch (std::exception& e) {
40865       {
40866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40867       };
40868     } catch (...) {
40869       {
40870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40871       };
40872     }
40873   }
40874   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40875
40876   //argout typemap for const std::string&
40877
40878   return jresult;
40879 }
40880
40881
40882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40883   void * jresult ;
40884   Dali::BaseHandle arg1 ;
40885   Dali::BaseHandle *argp1 ;
40886   Dali::ResourceImage result;
40887
40888   argp1 = (Dali::BaseHandle *)jarg1;
40889   if (!argp1) {
40890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40891     return 0;
40892   }
40893   arg1 = *argp1;
40894   {
40895     try {
40896       result = Dali::ResourceImage::DownCast(arg1);
40897     } catch (std::out_of_range& e) {
40898       {
40899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40900       };
40901     } catch (std::exception& e) {
40902       {
40903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40904       };
40905     } catch (...) {
40906       {
40907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40908       };
40909     }
40910   }
40911   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40917   int jresult ;
40918   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40919   Dali::LoadingState result;
40920
40921   arg1 = (Dali::ResourceImage *)jarg1;
40922   {
40923     try {
40924       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40925     } catch (std::out_of_range& e) {
40926       {
40927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40928       };
40929     } catch (std::exception& e) {
40930       {
40931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40936       };
40937     }
40938   }
40939   jresult = (int)result;
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40945   char * jresult ;
40946   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40947   std::string result;
40948
40949   arg1 = (Dali::ResourceImage *)jarg1;
40950   {
40951     try {
40952       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40953     } catch (std::out_of_range& e) {
40954       {
40955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40956       };
40957     } catch (std::exception& e) {
40958       {
40959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40960       };
40961     } catch (...) {
40962       {
40963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40964       };
40965     }
40966   }
40967   jresult = SWIG_csharp_string_callback((&result)->c_str());
40968   return jresult;
40969 }
40970
40971
40972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40973   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40974
40975   arg1 = (Dali::ResourceImage *)jarg1;
40976   {
40977     try {
40978       (arg1)->Reload();
40979     } catch (std::out_of_range& e) {
40980       {
40981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40982       };
40983     } catch (std::exception& e) {
40984       {
40985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40986       };
40987     } catch (...) {
40988       {
40989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40990       };
40991     }
40992   }
40993 }
40994
40995
40996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40997   void * jresult ;
40998   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40999   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
41000
41001   arg1 = (Dali::ResourceImage *)jarg1;
41002   {
41003     try {
41004       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41005     } catch (std::out_of_range& e) {
41006       {
41007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41008       };
41009     } catch (std::exception& e) {
41010       {
41011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41012       };
41013     } catch (...) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41016       };
41017     }
41018   }
41019   jresult = (void *)result;
41020   return jresult;
41021 }
41022
41023
41024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41025   void * jresult ;
41026   Dali::FrameBufferImage *result = 0 ;
41027
41028   {
41029     try {
41030       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41031     } catch (std::out_of_range& e) {
41032       {
41033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (std::exception& e) {
41036       {
41037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045   jresult = (void *)result;
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41051   void * jresult ;
41052   unsigned int arg1 ;
41053   unsigned int arg2 ;
41054   Dali::Pixel::Format arg3 ;
41055   Dali::RenderBuffer::Format arg4 ;
41056   Dali::FrameBufferImage result;
41057
41058   arg1 = (unsigned int)jarg1;
41059   arg2 = (unsigned int)jarg2;
41060   arg3 = (Dali::Pixel::Format)jarg3;
41061   arg4 = (Dali::RenderBuffer::Format)jarg4;
41062   {
41063     try {
41064       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41065     } catch (std::out_of_range& e) {
41066       {
41067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41068       };
41069     } catch (std::exception& e) {
41070       {
41071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41072       };
41073     } catch (...) {
41074       {
41075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41076       };
41077     }
41078   }
41079   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41080   return jresult;
41081 }
41082
41083
41084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41085   void * jresult ;
41086   unsigned int arg1 ;
41087   unsigned int arg2 ;
41088   Dali::Pixel::Format arg3 ;
41089   Dali::FrameBufferImage result;
41090
41091   arg1 = (unsigned int)jarg1;
41092   arg2 = (unsigned int)jarg2;
41093   arg3 = (Dali::Pixel::Format)jarg3;
41094   {
41095     try {
41096       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41097     } catch (std::out_of_range& e) {
41098       {
41099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41100       };
41101     } catch (std::exception& e) {
41102       {
41103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41108       };
41109     }
41110   }
41111   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41112   return jresult;
41113 }
41114
41115
41116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41117   void * jresult ;
41118   unsigned int arg1 ;
41119   unsigned int arg2 ;
41120   Dali::FrameBufferImage result;
41121
41122   arg1 = (unsigned int)jarg1;
41123   arg2 = (unsigned int)jarg2;
41124   {
41125     try {
41126       result = Dali::FrameBufferImage::New(arg1,arg2);
41127     } catch (std::out_of_range& e) {
41128       {
41129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41130       };
41131     } catch (std::exception& e) {
41132       {
41133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41134       };
41135     } catch (...) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41138       };
41139     }
41140   }
41141   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41142   return jresult;
41143 }
41144
41145
41146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41147   void * jresult ;
41148   unsigned int arg1 ;
41149   Dali::FrameBufferImage result;
41150
41151   arg1 = (unsigned int)jarg1;
41152   {
41153     try {
41154       result = Dali::FrameBufferImage::New(arg1);
41155     } catch (std::out_of_range& e) {
41156       {
41157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41158       };
41159     } catch (std::exception& e) {
41160       {
41161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (...) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41166       };
41167     }
41168   }
41169   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41170   return jresult;
41171 }
41172
41173
41174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41175   void * jresult ;
41176   Dali::FrameBufferImage result;
41177
41178   {
41179     try {
41180       result = Dali::FrameBufferImage::New();
41181     } catch (std::out_of_range& e) {
41182       {
41183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41184       };
41185     } catch (std::exception& e) {
41186       {
41187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41188       };
41189     } catch (...) {
41190       {
41191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41192       };
41193     }
41194   }
41195   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41196   return jresult;
41197 }
41198
41199
41200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41201   void * jresult ;
41202   Dali::NativeImageInterface *arg1 = 0 ;
41203   Dali::FrameBufferImage result;
41204
41205   arg1 = (Dali::NativeImageInterface *)jarg1;
41206   if (!arg1) {
41207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41208     return 0;
41209   }
41210   {
41211     try {
41212       result = Dali::FrameBufferImage::New(*arg1);
41213     } catch (std::out_of_range& e) {
41214       {
41215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41216       };
41217     } catch (std::exception& e) {
41218       {
41219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41220       };
41221     } catch (...) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41224       };
41225     }
41226   }
41227   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41228   return jresult;
41229 }
41230
41231
41232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41233   void * jresult ;
41234   Dali::BaseHandle arg1 ;
41235   Dali::BaseHandle *argp1 ;
41236   Dali::FrameBufferImage result;
41237
41238   argp1 = (Dali::BaseHandle *)jarg1;
41239   if (!argp1) {
41240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41241     return 0;
41242   }
41243   arg1 = *argp1;
41244   {
41245     try {
41246       result = Dali::FrameBufferImage::DownCast(arg1);
41247     } catch (std::out_of_range& e) {
41248       {
41249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41250       };
41251     } catch (std::exception& e) {
41252       {
41253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41254       };
41255     } catch (...) {
41256       {
41257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41258       };
41259     }
41260   }
41261   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41262   return jresult;
41263 }
41264
41265
41266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41267   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41268
41269   arg1 = (Dali::FrameBufferImage *)jarg1;
41270   {
41271     try {
41272       delete arg1;
41273     } catch (std::out_of_range& e) {
41274       {
41275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41276       };
41277     } catch (std::exception& e) {
41278       {
41279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41280       };
41281     } catch (...) {
41282       {
41283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41284       };
41285     }
41286   }
41287 }
41288
41289
41290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41291   void * jresult ;
41292   Dali::FrameBufferImage *arg1 = 0 ;
41293   Dali::FrameBufferImage *result = 0 ;
41294
41295   arg1 = (Dali::FrameBufferImage *)jarg1;
41296   if (!arg1) {
41297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41298     return 0;
41299   }
41300   {
41301     try {
41302       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41303     } catch (std::out_of_range& e) {
41304       {
41305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (std::exception& e) {
41308       {
41309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41310       };
41311     } catch (...) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41314       };
41315     }
41316   }
41317   jresult = (void *)result;
41318   return jresult;
41319 }
41320
41321
41322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41323   void * jresult ;
41324   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41325   Dali::FrameBufferImage *arg2 = 0 ;
41326   Dali::FrameBufferImage *result = 0 ;
41327
41328   arg1 = (Dali::FrameBufferImage *)jarg1;
41329   arg2 = (Dali::FrameBufferImage *)jarg2;
41330   if (!arg2) {
41331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41332     return 0;
41333   }
41334   {
41335     try {
41336       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (...) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41348       };
41349     }
41350   }
41351   jresult = (void *)result;
41352   return jresult;
41353 }
41354
41355
41356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41357   void * jresult ;
41358   Dali::NinePatchImage *result = 0 ;
41359
41360   {
41361     try {
41362       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41363     } catch (std::out_of_range& e) {
41364       {
41365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41366       };
41367     } catch (std::exception& e) {
41368       {
41369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41370       };
41371     } catch (...) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41374       };
41375     }
41376   }
41377   jresult = (void *)result;
41378   return jresult;
41379 }
41380
41381
41382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41383   void * jresult ;
41384   std::string *arg1 = 0 ;
41385   Dali::NinePatchImage result;
41386
41387   if (!jarg1) {
41388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41389     return 0;
41390   }
41391   std::string arg1_str(jarg1);
41392   arg1 = &arg1_str;
41393   {
41394     try {
41395       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41396     } catch (std::out_of_range& e) {
41397       {
41398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41399       };
41400     } catch (std::exception& e) {
41401       {
41402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41403       };
41404     } catch (...) {
41405       {
41406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41407       };
41408     }
41409   }
41410   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41411
41412   //argout typemap for const std::string&
41413
41414   return jresult;
41415 }
41416
41417
41418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41419   void * jresult ;
41420   Dali::BaseHandle arg1 ;
41421   Dali::BaseHandle *argp1 ;
41422   Dali::NinePatchImage result;
41423
41424   argp1 = (Dali::BaseHandle *)jarg1;
41425   if (!argp1) {
41426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41427     return 0;
41428   }
41429   arg1 = *argp1;
41430   {
41431     try {
41432       result = Dali::NinePatchImage::DownCast(arg1);
41433     } catch (std::out_of_range& e) {
41434       {
41435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (std::exception& e) {
41438       {
41439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41453   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41454
41455   arg1 = (Dali::NinePatchImage *)jarg1;
41456   {
41457     try {
41458       delete arg1;
41459     } catch (std::out_of_range& e) {
41460       {
41461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41462       };
41463     } catch (std::exception& e) {
41464       {
41465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41466       };
41467     } catch (...) {
41468       {
41469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41470       };
41471     }
41472   }
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41477   void * jresult ;
41478   Dali::NinePatchImage *arg1 = 0 ;
41479   Dali::NinePatchImage *result = 0 ;
41480
41481   arg1 = (Dali::NinePatchImage *)jarg1;
41482   if (!arg1) {
41483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41484     return 0;
41485   }
41486   {
41487     try {
41488       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41489     } catch (std::out_of_range& e) {
41490       {
41491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41492       };
41493     } catch (std::exception& e) {
41494       {
41495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41496       };
41497     } catch (...) {
41498       {
41499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41500       };
41501     }
41502   }
41503   jresult = (void *)result;
41504   return jresult;
41505 }
41506
41507
41508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41509   void * jresult ;
41510   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41511   Dali::NinePatchImage *arg2 = 0 ;
41512   Dali::NinePatchImage *result = 0 ;
41513
41514   arg1 = (Dali::NinePatchImage *)jarg1;
41515   arg2 = (Dali::NinePatchImage *)jarg2;
41516   if (!arg2) {
41517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41518     return 0;
41519   }
41520   {
41521     try {
41522       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41523     } catch (std::out_of_range& e) {
41524       {
41525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41526       };
41527     } catch (std::exception& e) {
41528       {
41529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41530       };
41531     } catch (...) {
41532       {
41533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41534       };
41535     }
41536   }
41537   jresult = (void *)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41543   void * jresult ;
41544   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41545   Dali::Vector4 result;
41546
41547   arg1 = (Dali::NinePatchImage *)jarg1;
41548   {
41549     try {
41550       result = (arg1)->GetStretchBorders();
41551     } catch (std::out_of_range& e) {
41552       {
41553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41554       };
41555     } catch (std::exception& e) {
41556       {
41557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41562       };
41563     }
41564   }
41565   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41566   return jresult;
41567 }
41568
41569
41570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41571   void * jresult ;
41572   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41573   Dali::NinePatchImage::StretchRanges *result = 0 ;
41574
41575   arg1 = (Dali::NinePatchImage *)jarg1;
41576   {
41577     try {
41578       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41579     } catch (std::out_of_range& e) {
41580       {
41581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (std::exception& e) {
41584       {
41585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41586       };
41587     } catch (...) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41590       };
41591     }
41592   }
41593   jresult = (void *)result;
41594   return jresult;
41595 }
41596
41597
41598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41599   void * jresult ;
41600   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41601   Dali::NinePatchImage::StretchRanges *result = 0 ;
41602
41603   arg1 = (Dali::NinePatchImage *)jarg1;
41604   {
41605     try {
41606       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41607     } catch (std::out_of_range& e) {
41608       {
41609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41610       };
41611     } catch (std::exception& e) {
41612       {
41613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41614       };
41615     } catch (...) {
41616       {
41617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41618       };
41619     }
41620   }
41621   jresult = (void *)result;
41622   return jresult;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41627   void * jresult ;
41628   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41629   Dali::Rect< int > result;
41630
41631   arg1 = (Dali::NinePatchImage *)jarg1;
41632   {
41633     try {
41634       result = (arg1)->GetChildRectangle();
41635     } catch (std::out_of_range& e) {
41636       {
41637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (std::exception& e) {
41640       {
41641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41642       };
41643     } catch (...) {
41644       {
41645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41646       };
41647     }
41648   }
41649   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41650   return jresult;
41651 }
41652
41653
41654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41655   void * jresult ;
41656   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41657   Dali::BufferImage result;
41658
41659   arg1 = (Dali::NinePatchImage *)jarg1;
41660   {
41661     try {
41662       result = (arg1)->CreateCroppedBufferImage();
41663     } catch (std::out_of_range& e) {
41664       {
41665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41666       };
41667     } catch (std::exception& e) {
41668       {
41669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41670       };
41671     } catch (...) {
41672       {
41673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41674       };
41675     }
41676   }
41677   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41683   unsigned int jresult ;
41684   std::string *arg1 = 0 ;
41685   bool result;
41686
41687   if (!jarg1) {
41688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41689     return 0;
41690   }
41691   std::string arg1_str(jarg1);
41692   arg1 = &arg1_str;
41693   {
41694     try {
41695       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41696     } catch (std::out_of_range& e) {
41697       {
41698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41699       };
41700     } catch (std::exception& e) {
41701       {
41702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41703       };
41704     } catch (...) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41707       };
41708     }
41709   }
41710   jresult = result;
41711
41712   //argout typemap for const std::string&
41713
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41719   int jresult ;
41720   int result;
41721
41722   result = (int)Dali::CameraActor::Property::TYPE;
41723   jresult = (int)result;
41724   return jresult;
41725 }
41726
41727
41728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41729   int jresult ;
41730   int result;
41731
41732   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41733   jresult = (int)result;
41734   return jresult;
41735 }
41736
41737
41738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41739   int jresult ;
41740   int result;
41741
41742   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41743   jresult = (int)result;
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41749   int jresult ;
41750   int result;
41751
41752   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41753   jresult = (int)result;
41754   return jresult;
41755 }
41756
41757
41758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41759   int jresult ;
41760   int result;
41761
41762   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41763   jresult = (int)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41769   int jresult ;
41770   int result;
41771
41772   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41773   jresult = (int)result;
41774   return jresult;
41775 }
41776
41777
41778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41779   int jresult ;
41780   int result;
41781
41782   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41783   jresult = (int)result;
41784   return jresult;
41785 }
41786
41787
41788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41789   int jresult ;
41790   int result;
41791
41792   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41793   jresult = (int)result;
41794   return jresult;
41795 }
41796
41797
41798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41799   int jresult ;
41800   int result;
41801
41802   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41803   jresult = (int)result;
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41809   int jresult ;
41810   int result;
41811
41812   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41813   jresult = (int)result;
41814   return jresult;
41815 }
41816
41817
41818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41819   int jresult ;
41820   int result;
41821
41822   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41823   jresult = (int)result;
41824   return jresult;
41825 }
41826
41827
41828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41829   int jresult ;
41830   int result;
41831
41832   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41833   jresult = (int)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41839   int jresult ;
41840   int result;
41841
41842   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41843   jresult = (int)result;
41844   return jresult;
41845 }
41846
41847
41848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41849   int jresult ;
41850   int result;
41851
41852   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41853   jresult = (int)result;
41854   return jresult;
41855 }
41856
41857
41858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41859   void * jresult ;
41860   Dali::CameraActor::Property *result = 0 ;
41861
41862   {
41863     try {
41864       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41865     } catch (std::out_of_range& e) {
41866       {
41867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (std::exception& e) {
41870       {
41871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879   jresult = (void *)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41885   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41886
41887   arg1 = (Dali::CameraActor::Property *)jarg1;
41888   {
41889     try {
41890       delete arg1;
41891     } catch (std::out_of_range& e) {
41892       {
41893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41894       };
41895     } catch (std::exception& e) {
41896       {
41897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41898       };
41899     } catch (...) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41902       };
41903     }
41904   }
41905 }
41906
41907
41908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41909   void * jresult ;
41910   Dali::CameraActor *result = 0 ;
41911
41912   {
41913     try {
41914       result = (Dali::CameraActor *)new Dali::CameraActor();
41915     } catch (std::out_of_range& e) {
41916       {
41917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41918       };
41919     } catch (std::exception& e) {
41920       {
41921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41922       };
41923     } catch (...) {
41924       {
41925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41926       };
41927     }
41928   }
41929   jresult = (void *)result;
41930   return jresult;
41931 }
41932
41933
41934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41935   void * jresult ;
41936   Dali::CameraActor result;
41937
41938   {
41939     try {
41940       result = Dali::CameraActor::New();
41941     } catch (std::out_of_range& e) {
41942       {
41943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (std::exception& e) {
41946       {
41947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41948       };
41949     } catch (...) {
41950       {
41951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41952       };
41953     }
41954   }
41955   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41956   return jresult;
41957 }
41958
41959
41960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41961   void * jresult ;
41962   Dali::Size *arg1 = 0 ;
41963   Dali::CameraActor result;
41964
41965   arg1 = (Dali::Size *)jarg1;
41966   if (!arg1) {
41967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41968     return 0;
41969   }
41970   {
41971     try {
41972       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41973     } catch (std::out_of_range& e) {
41974       {
41975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41976       };
41977     } catch (std::exception& e) {
41978       {
41979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41980       };
41981     } catch (...) {
41982       {
41983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41984       };
41985     }
41986   }
41987   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41988   return jresult;
41989 }
41990
41991
41992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41993   void * jresult ;
41994   Dali::BaseHandle arg1 ;
41995   Dali::BaseHandle *argp1 ;
41996   Dali::CameraActor result;
41997
41998   argp1 = (Dali::BaseHandle *)jarg1;
41999   if (!argp1) {
42000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42001     return 0;
42002   }
42003   arg1 = *argp1;
42004   {
42005     try {
42006       result = Dali::CameraActor::DownCast(arg1);
42007     } catch (std::out_of_range& e) {
42008       {
42009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (std::exception& e) {
42012       {
42013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42014       };
42015     } catch (...) {
42016       {
42017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42018       };
42019     }
42020   }
42021   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42022   return jresult;
42023 }
42024
42025
42026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42027   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42028
42029   arg1 = (Dali::CameraActor *)jarg1;
42030   {
42031     try {
42032       delete arg1;
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42040       };
42041     } catch (...) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42044       };
42045     }
42046   }
42047 }
42048
42049
42050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42051   void * jresult ;
42052   Dali::CameraActor *arg1 = 0 ;
42053   Dali::CameraActor *result = 0 ;
42054
42055   arg1 = (Dali::CameraActor *)jarg1;
42056   if (!arg1) {
42057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42058     return 0;
42059   }
42060   {
42061     try {
42062       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42063     } catch (std::out_of_range& e) {
42064       {
42065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42066       };
42067     } catch (std::exception& e) {
42068       {
42069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42070       };
42071     } catch (...) {
42072       {
42073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42074       };
42075     }
42076   }
42077   jresult = (void *)result;
42078   return jresult;
42079 }
42080
42081
42082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42083   void * jresult ;
42084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42085   Dali::CameraActor *arg2 = 0 ;
42086   Dali::CameraActor *result = 0 ;
42087
42088   arg1 = (Dali::CameraActor *)jarg1;
42089   arg2 = (Dali::CameraActor *)jarg2;
42090   if (!arg2) {
42091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42092     return 0;
42093   }
42094   {
42095     try {
42096       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42097     } catch (std::out_of_range& e) {
42098       {
42099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42100       };
42101     } catch (std::exception& e) {
42102       {
42103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42104       };
42105     } catch (...) {
42106       {
42107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42108       };
42109     }
42110   }
42111   jresult = (void *)result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42118   Dali::Camera::Type arg2 ;
42119
42120   arg1 = (Dali::CameraActor *)jarg1;
42121   arg2 = (Dali::Camera::Type)jarg2;
42122   {
42123     try {
42124       (arg1)->SetType(arg2);
42125     } catch (std::out_of_range& e) {
42126       {
42127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42128       };
42129     } catch (std::exception& e) {
42130       {
42131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42132       };
42133     } catch (...) {
42134       {
42135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42136       };
42137     }
42138   }
42139 }
42140
42141
42142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42143   int jresult ;
42144   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42145   Dali::Camera::Type result;
42146
42147   arg1 = (Dali::CameraActor *)jarg1;
42148   {
42149     try {
42150       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42151     } catch (std::out_of_range& e) {
42152       {
42153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42154       };
42155     } catch (std::exception& e) {
42156       {
42157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42158       };
42159     } catch (...) {
42160       {
42161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42162       };
42163     }
42164   }
42165   jresult = (int)result;
42166   return jresult;
42167 }
42168
42169
42170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42171   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42172   Dali::Camera::ProjectionMode arg2 ;
42173
42174   arg1 = (Dali::CameraActor *)jarg1;
42175   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42176   {
42177     try {
42178       (arg1)->SetProjectionMode(arg2);
42179     } catch (std::out_of_range& e) {
42180       {
42181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42182       };
42183     } catch (std::exception& e) {
42184       {
42185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42186       };
42187     } catch (...) {
42188       {
42189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42190       };
42191     }
42192   }
42193 }
42194
42195
42196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42197   int jresult ;
42198   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42199   Dali::Camera::ProjectionMode result;
42200
42201   arg1 = (Dali::CameraActor *)jarg1;
42202   {
42203     try {
42204       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42205     } catch (std::out_of_range& e) {
42206       {
42207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42208       };
42209     } catch (std::exception& e) {
42210       {
42211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (...) {
42214       {
42215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42216       };
42217     }
42218   }
42219   jresult = (int)result;
42220   return jresult;
42221 }
42222
42223
42224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42225   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42226   float arg2 ;
42227
42228   arg1 = (Dali::CameraActor *)jarg1;
42229   arg2 = (float)jarg2;
42230   {
42231     try {
42232       (arg1)->SetFieldOfView(arg2);
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42244       };
42245     }
42246   }
42247 }
42248
42249
42250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42251   float jresult ;
42252   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42253   float result;
42254
42255   arg1 = (Dali::CameraActor *)jarg1;
42256   {
42257     try {
42258       result = (float)(arg1)->GetFieldOfView();
42259     } catch (std::out_of_range& e) {
42260       {
42261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42262       };
42263     } catch (std::exception& e) {
42264       {
42265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42266       };
42267     } catch (...) {
42268       {
42269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42270       };
42271     }
42272   }
42273   jresult = result;
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42279   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42280   float arg2 ;
42281
42282   arg1 = (Dali::CameraActor *)jarg1;
42283   arg2 = (float)jarg2;
42284   {
42285     try {
42286       (arg1)->SetAspectRatio(arg2);
42287     } catch (std::out_of_range& e) {
42288       {
42289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42290       };
42291     } catch (std::exception& e) {
42292       {
42293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42294       };
42295     } catch (...) {
42296       {
42297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42298       };
42299     }
42300   }
42301 }
42302
42303
42304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42305   float jresult ;
42306   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42307   float result;
42308
42309   arg1 = (Dali::CameraActor *)jarg1;
42310   {
42311     try {
42312       result = (float)(arg1)->GetAspectRatio();
42313     } catch (std::out_of_range& e) {
42314       {
42315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (std::exception& e) {
42318       {
42319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42320       };
42321     } catch (...) {
42322       {
42323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42324       };
42325     }
42326   }
42327   jresult = result;
42328   return jresult;
42329 }
42330
42331
42332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42333   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42334   float arg2 ;
42335
42336   arg1 = (Dali::CameraActor *)jarg1;
42337   arg2 = (float)jarg2;
42338   {
42339     try {
42340       (arg1)->SetNearClippingPlane(arg2);
42341     } catch (std::out_of_range& e) {
42342       {
42343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42344       };
42345     } catch (std::exception& e) {
42346       {
42347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42352       };
42353     }
42354   }
42355 }
42356
42357
42358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42359   float jresult ;
42360   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42361   float result;
42362
42363   arg1 = (Dali::CameraActor *)jarg1;
42364   {
42365     try {
42366       result = (float)(arg1)->GetNearClippingPlane();
42367     } catch (std::out_of_range& e) {
42368       {
42369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42370       };
42371     } catch (std::exception& e) {
42372       {
42373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42374       };
42375     } catch (...) {
42376       {
42377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42378       };
42379     }
42380   }
42381   jresult = result;
42382   return jresult;
42383 }
42384
42385
42386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42387   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42388   float arg2 ;
42389
42390   arg1 = (Dali::CameraActor *)jarg1;
42391   arg2 = (float)jarg2;
42392   {
42393     try {
42394       (arg1)->SetFarClippingPlane(arg2);
42395     } catch (std::out_of_range& e) {
42396       {
42397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42398       };
42399     } catch (std::exception& e) {
42400       {
42401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42402       };
42403     } catch (...) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42406       };
42407     }
42408   }
42409 }
42410
42411
42412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42413   float jresult ;
42414   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42415   float result;
42416
42417   arg1 = (Dali::CameraActor *)jarg1;
42418   {
42419     try {
42420       result = (float)(arg1)->GetFarClippingPlane();
42421     } catch (std::out_of_range& e) {
42422       {
42423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42424       };
42425     } catch (std::exception& e) {
42426       {
42427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42428       };
42429     } catch (...) {
42430       {
42431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42432       };
42433     }
42434   }
42435   jresult = result;
42436   return jresult;
42437 }
42438
42439
42440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42441   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42442   Dali::Vector3 *arg2 = 0 ;
42443
42444   arg1 = (Dali::CameraActor *)jarg1;
42445   arg2 = (Dali::Vector3 *)jarg2;
42446   if (!arg2) {
42447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42448     return ;
42449   }
42450   {
42451     try {
42452       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42453     } catch (std::out_of_range& e) {
42454       {
42455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42456       };
42457     } catch (std::exception& e) {
42458       {
42459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42460       };
42461     } catch (...) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42464       };
42465     }
42466   }
42467 }
42468
42469
42470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42471   void * jresult ;
42472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42473   Dali::Vector3 result;
42474
42475   arg1 = (Dali::CameraActor *)jarg1;
42476   {
42477     try {
42478       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42479     } catch (std::out_of_range& e) {
42480       {
42481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42482       };
42483     } catch (std::exception& e) {
42484       {
42485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (...) {
42488       {
42489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42490       };
42491     }
42492   }
42493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42494   return jresult;
42495 }
42496
42497
42498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42499   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42500   bool arg2 ;
42501
42502   arg1 = (Dali::CameraActor *)jarg1;
42503   arg2 = jarg2 ? true : false;
42504   {
42505     try {
42506       (arg1)->SetInvertYAxis(arg2);
42507     } catch (std::out_of_range& e) {
42508       {
42509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42510       };
42511     } catch (std::exception& e) {
42512       {
42513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42514       };
42515     } catch (...) {
42516       {
42517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42518       };
42519     }
42520   }
42521 }
42522
42523
42524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42525   unsigned int jresult ;
42526   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42527   bool result;
42528
42529   arg1 = (Dali::CameraActor *)jarg1;
42530   {
42531     try {
42532       result = (bool)(arg1)->GetInvertYAxis();
42533     } catch (std::out_of_range& e) {
42534       {
42535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42536       };
42537     } catch (std::exception& e) {
42538       {
42539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42540       };
42541     } catch (...) {
42542       {
42543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42544       };
42545     }
42546   }
42547   jresult = result;
42548   return jresult;
42549 }
42550
42551
42552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42553   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42554   Dali::Size *arg2 = 0 ;
42555
42556   arg1 = (Dali::CameraActor *)jarg1;
42557   arg2 = (Dali::Size *)jarg2;
42558   if (!arg2) {
42559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42560     return ;
42561   }
42562   {
42563     try {
42564       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42565     } catch (std::out_of_range& e) {
42566       {
42567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42568       };
42569     } catch (std::exception& e) {
42570       {
42571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42572       };
42573     } catch (...) {
42574       {
42575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42576       };
42577     }
42578   }
42579 }
42580
42581
42582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42583   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42584   Dali::Size *arg2 = 0 ;
42585
42586   arg1 = (Dali::CameraActor *)jarg1;
42587   arg2 = (Dali::Size *)jarg2;
42588   if (!arg2) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42590     return ;
42591   }
42592   {
42593     try {
42594       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42595     } catch (std::out_of_range& e) {
42596       {
42597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42598       };
42599     } catch (std::exception& e) {
42600       {
42601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42602       };
42603     } catch (...) {
42604       {
42605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42606       };
42607     }
42608   }
42609 }
42610
42611
42612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42613   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42614   float arg2 ;
42615   float arg3 ;
42616   float arg4 ;
42617   float arg5 ;
42618   float arg6 ;
42619   float arg7 ;
42620
42621   arg1 = (Dali::CameraActor *)jarg1;
42622   arg2 = (float)jarg2;
42623   arg3 = (float)jarg3;
42624   arg4 = (float)jarg4;
42625   arg5 = (float)jarg5;
42626   arg6 = (float)jarg6;
42627   arg7 = (float)jarg7;
42628   {
42629     try {
42630       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42631     } catch (std::out_of_range& e) {
42632       {
42633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42634       };
42635     } catch (std::exception& e) {
42636       {
42637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42638       };
42639     } catch (...) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42642       };
42643     }
42644   }
42645 }
42646
42647
42648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42649   void * jresult ;
42650   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42651
42652   {
42653     try {
42654       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42655     } catch (std::out_of_range& e) {
42656       {
42657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (std::exception& e) {
42660       {
42661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (...) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42666       };
42667     }
42668   }
42669   jresult = (void *)result;
42670   return jresult;
42671 }
42672
42673
42674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42675   void * jresult ;
42676   std::string arg1 ;
42677   Dali::Property::Value arg2 ;
42678   Dali::Property::Value *argp2 ;
42679   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42680
42681   if (!jarg1) {
42682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42683     return 0;
42684   }
42685   (&arg1)->assign(jarg1);
42686   argp2 = (Dali::Property::Value *)jarg2;
42687   if (!argp2) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42689     return 0;
42690   }
42691   arg2 = *argp2;
42692   {
42693     try {
42694       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42695     } catch (std::out_of_range& e) {
42696       {
42697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42698       };
42699     } catch (std::exception& e) {
42700       {
42701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42702       };
42703     } catch (...) {
42704       {
42705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42706       };
42707     }
42708   }
42709   jresult = (void *)result;
42710   return jresult;
42711 }
42712
42713
42714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42715   void * jresult ;
42716   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42717   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42718
42719   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42720   if (!arg1) {
42721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42722     return 0;
42723   }
42724   {
42725     try {
42726       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
42727     } catch (std::out_of_range& e) {
42728       {
42729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42730       };
42731     } catch (std::exception& e) {
42732       {
42733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42734       };
42735     } catch (...) {
42736       {
42737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42738       };
42739     }
42740   }
42741   jresult = (void *)result;
42742   return jresult;
42743 }
42744
42745
42746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42747   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42748   std::string *arg2 = 0 ;
42749
42750   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42751   if (!jarg2) {
42752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42753     return ;
42754   }
42755   std::string arg2_str(jarg2);
42756   arg2 = &arg2_str;
42757   if (arg1) (arg1)->first = *arg2;
42758
42759   //argout typemap for const std::string&
42760
42761 }
42762
42763
42764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42765   char * jresult ;
42766   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42767   std::string *result = 0 ;
42768
42769   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42770   result = (std::string *) & ((arg1)->first);
42771   jresult = SWIG_csharp_string_callback(result->c_str());
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42777   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42778   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42779
42780   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42781   arg2 = (Dali::Property::Value *)jarg2;
42782   if (arg1) (arg1)->second = *arg2;
42783 }
42784
42785
42786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42787   void * jresult ;
42788   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42789   Dali::Property::Value *result = 0 ;
42790
42791   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42792   result = (Dali::Property::Value *)& ((arg1)->second);
42793   jresult = (void *)result;
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42799   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42800
42801   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42802   {
42803     try {
42804       delete arg1;
42805     } catch (std::out_of_range& e) {
42806       {
42807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42808       };
42809     } catch (std::exception& e) {
42810       {
42811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42812       };
42813     } catch (...) {
42814       {
42815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42816       };
42817     }
42818   }
42819 }
42820
42821
42822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42824
42825   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42826   {
42827     try {
42828       (arg1)->clear();
42829     } catch (std::out_of_range& e) {
42830       {
42831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42832       };
42833     } catch (std::exception& e) {
42834       {
42835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42836       };
42837     } catch (...) {
42838       {
42839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42840       };
42841     }
42842   }
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42847   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42848   Dali::TouchPoint *arg2 = 0 ;
42849
42850   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42851   arg2 = (Dali::TouchPoint *)jarg2;
42852   if (!arg2) {
42853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42854     return ;
42855   }
42856   {
42857     try {
42858       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42866       };
42867     } catch (...) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42870       };
42871     }
42872   }
42873 }
42874
42875
42876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42877   unsigned long jresult ;
42878   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42879   std::vector< Dali::TouchPoint >::size_type result;
42880
42881   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42882   {
42883     try {
42884       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42885     } catch (std::out_of_range& e) {
42886       {
42887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (std::exception& e) {
42890       {
42891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42892       };
42893     } catch (...) {
42894       {
42895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42896       };
42897     }
42898   }
42899   jresult = (unsigned long)result;
42900   return jresult;
42901 }
42902
42903
42904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42905   unsigned long jresult ;
42906   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42907   std::vector< Dali::TouchPoint >::size_type result;
42908
42909   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42910   {
42911     try {
42912       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42913     } catch (std::out_of_range& e) {
42914       {
42915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42916       };
42917     } catch (std::exception& e) {
42918       {
42919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42920       };
42921     } catch (...) {
42922       {
42923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42924       };
42925     }
42926   }
42927   jresult = (unsigned long)result;
42928   return jresult;
42929 }
42930
42931
42932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42933   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42934   std::vector< Dali::TouchPoint >::size_type arg2 ;
42935
42936   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42937   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42938   {
42939     try {
42940       (arg1)->reserve(arg2);
42941     } catch (std::out_of_range& e) {
42942       {
42943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42944       };
42945     } catch (std::exception& e) {
42946       {
42947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42948       };
42949     } catch (...) {
42950       {
42951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42952       };
42953     }
42954   }
42955 }
42956
42957
42958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42959   void * jresult ;
42960   std::vector< Dali::TouchPoint > *result = 0 ;
42961
42962   {
42963     try {
42964       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42965     } catch (std::out_of_range& e) {
42966       {
42967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42968       };
42969     } catch (std::exception& e) {
42970       {
42971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (...) {
42974       {
42975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42976       };
42977     }
42978   }
42979   jresult = (void *)result;
42980   return jresult;
42981 }
42982
42983
42984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42985   void * jresult ;
42986   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42987   std::vector< Dali::TouchPoint > *result = 0 ;
42988
42989   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42990   if (!arg1) {
42991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42992     return 0;
42993   }
42994   {
42995     try {
42996       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42997     } catch (std::out_of_range& e) {
42998       {
42999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43000       };
43001     } catch (std::exception& e) {
43002       {
43003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (...) {
43006       {
43007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43008       };
43009     }
43010   }
43011   jresult = (void *)result;
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43017   void * jresult ;
43018   int arg1 ;
43019   std::vector< Dali::TouchPoint > *result = 0 ;
43020
43021   arg1 = (int)jarg1;
43022   {
43023     try {
43024       try {
43025         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43026       }
43027       catch(std::out_of_range &_e) {
43028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43029         return 0;
43030       }
43031
43032     } catch (std::out_of_range& e) {
43033       {
43034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43035       };
43036     } catch (std::exception& e) {
43037       {
43038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43039       };
43040     } catch (...) {
43041       {
43042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43043       };
43044     }
43045   }
43046   jresult = (void *)result;
43047   return jresult;
43048 }
43049
43050
43051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43052   void * jresult ;
43053   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43054   int arg2 ;
43055   SwigValueWrapper< Dali::TouchPoint > result;
43056
43057   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43058   arg2 = (int)jarg2;
43059   {
43060     try {
43061       try {
43062         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43063       }
43064       catch(std::out_of_range &_e) {
43065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43066         return 0;
43067       }
43068
43069     } catch (std::out_of_range& e) {
43070       {
43071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43072       };
43073     } catch (std::exception& e) {
43074       {
43075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43076       };
43077     } catch (...) {
43078       {
43079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43080       };
43081     }
43082   }
43083   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43084   return jresult;
43085 }
43086
43087
43088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43089   void * jresult ;
43090   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43091   int arg2 ;
43092   Dali::TouchPoint *result = 0 ;
43093
43094   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43095   arg2 = (int)jarg2;
43096   {
43097     try {
43098       try {
43099         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43100       }
43101       catch(std::out_of_range &_e) {
43102         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43103         return 0;
43104       }
43105
43106     } catch (std::out_of_range& e) {
43107       {
43108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (std::exception& e) {
43111       {
43112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (...) {
43115       {
43116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43117       };
43118     }
43119   }
43120   jresult = (void *)result;
43121   return jresult;
43122 }
43123
43124
43125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43126   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43127   int arg2 ;
43128   Dali::TouchPoint *arg3 = 0 ;
43129
43130   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43131   arg2 = (int)jarg2;
43132   arg3 = (Dali::TouchPoint *)jarg3;
43133   if (!arg3) {
43134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43135     return ;
43136   }
43137   {
43138     try {
43139       try {
43140         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43141       }
43142       catch(std::out_of_range &_e) {
43143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43144         return ;
43145       }
43146
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43154       };
43155     } catch (...) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43158       };
43159     }
43160   }
43161 }
43162
43163
43164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43165   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43166   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43167
43168   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43169   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43170   if (!arg2) {
43171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43172     return ;
43173   }
43174   {
43175     try {
43176       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43177     } catch (std::out_of_range& e) {
43178       {
43179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43180       };
43181     } catch (std::exception& e) {
43182       {
43183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43184       };
43185     } catch (...) {
43186       {
43187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43188       };
43189     }
43190   }
43191 }
43192
43193
43194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43195   void * jresult ;
43196   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43197   int arg2 ;
43198   int arg3 ;
43199   std::vector< Dali::TouchPoint > *result = 0 ;
43200
43201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43202   arg2 = (int)jarg2;
43203   arg3 = (int)jarg3;
43204   {
43205     try {
43206       try {
43207         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43208       }
43209       catch(std::out_of_range &_e) {
43210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43211         return 0;
43212       }
43213       catch(std::invalid_argument &_e) {
43214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43215         return 0;
43216       }
43217
43218     } catch (std::out_of_range& e) {
43219       {
43220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43221       };
43222     } catch (std::exception& e) {
43223       {
43224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43225       };
43226     } catch (...) {
43227       {
43228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43229       };
43230     }
43231   }
43232   jresult = (void *)result;
43233   return jresult;
43234 }
43235
43236
43237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43238   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43239   int arg2 ;
43240   Dali::TouchPoint *arg3 = 0 ;
43241
43242   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43243   arg2 = (int)jarg2;
43244   arg3 = (Dali::TouchPoint *)jarg3;
43245   if (!arg3) {
43246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43247     return ;
43248   }
43249   {
43250     try {
43251       try {
43252         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43253       }
43254       catch(std::out_of_range &_e) {
43255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43256         return ;
43257       }
43258
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43266       };
43267     } catch (...) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43270       };
43271     }
43272   }
43273 }
43274
43275
43276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43277   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43278   int arg2 ;
43279   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43280
43281   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43282   arg2 = (int)jarg2;
43283   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43284   if (!arg3) {
43285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43286     return ;
43287   }
43288   {
43289     try {
43290       try {
43291         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43292       }
43293       catch(std::out_of_range &_e) {
43294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43295         return ;
43296       }
43297
43298     } catch (std::out_of_range& e) {
43299       {
43300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (std::exception& e) {
43303       {
43304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (...) {
43307       {
43308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43309       };
43310     }
43311   }
43312 }
43313
43314
43315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43316   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43317   int arg2 ;
43318
43319   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43320   arg2 = (int)jarg2;
43321   {
43322     try {
43323       try {
43324         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43325       }
43326       catch(std::out_of_range &_e) {
43327         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43328         return ;
43329       }
43330
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43338       };
43339     } catch (...) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43342       };
43343     }
43344   }
43345 }
43346
43347
43348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43349   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43350   int arg2 ;
43351   int arg3 ;
43352
43353   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43354   arg2 = (int)jarg2;
43355   arg3 = (int)jarg3;
43356   {
43357     try {
43358       try {
43359         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43360       }
43361       catch(std::out_of_range &_e) {
43362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43363         return ;
43364       }
43365       catch(std::invalid_argument &_e) {
43366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43367         return ;
43368       }
43369
43370     } catch (std::out_of_range& e) {
43371       {
43372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43373       };
43374     } catch (std::exception& e) {
43375       {
43376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43377       };
43378     } catch (...) {
43379       {
43380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43381       };
43382     }
43383   }
43384 }
43385
43386
43387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43388   void * jresult ;
43389   Dali::TouchPoint *arg1 = 0 ;
43390   int arg2 ;
43391   std::vector< Dali::TouchPoint > *result = 0 ;
43392
43393   arg1 = (Dali::TouchPoint *)jarg1;
43394   if (!arg1) {
43395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43396     return 0;
43397   }
43398   arg2 = (int)jarg2;
43399   {
43400     try {
43401       try {
43402         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43403       }
43404       catch(std::out_of_range &_e) {
43405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43406         return 0;
43407       }
43408
43409     } catch (std::out_of_range& e) {
43410       {
43411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (std::exception& e) {
43414       {
43415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (...) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43420       };
43421     }
43422   }
43423   jresult = (void *)result;
43424   return jresult;
43425 }
43426
43427
43428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43429   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43430
43431   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43432   {
43433     try {
43434       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43435     } catch (std::out_of_range& e) {
43436       {
43437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43438       };
43439     } catch (std::exception& e) {
43440       {
43441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43442       };
43443     } catch (...) {
43444       {
43445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43446       };
43447     }
43448   }
43449 }
43450
43451
43452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43454   int arg2 ;
43455   int arg3 ;
43456
43457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43458   arg2 = (int)jarg2;
43459   arg3 = (int)jarg3;
43460   {
43461     try {
43462       try {
43463         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43464       }
43465       catch(std::out_of_range &_e) {
43466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43467         return ;
43468       }
43469       catch(std::invalid_argument &_e) {
43470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43471         return ;
43472       }
43473
43474     } catch (std::out_of_range& e) {
43475       {
43476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43477       };
43478     } catch (std::exception& e) {
43479       {
43480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43481       };
43482     } catch (...) {
43483       {
43484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43485       };
43486     }
43487   }
43488 }
43489
43490
43491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43492   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43493   int arg2 ;
43494   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43495
43496   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43497   arg2 = (int)jarg2;
43498   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43499   if (!arg3) {
43500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43501     return ;
43502   }
43503   {
43504     try {
43505       try {
43506         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43507       }
43508       catch(std::out_of_range &_e) {
43509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43510         return ;
43511       }
43512
43513     } catch (std::out_of_range& e) {
43514       {
43515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43516       };
43517     } catch (std::exception& e) {
43518       {
43519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43520       };
43521     } catch (...) {
43522       {
43523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43524       };
43525     }
43526   }
43527 }
43528
43529
43530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43531   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43532
43533   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43534   {
43535     try {
43536       delete arg1;
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43548       };
43549     }
43550   }
43551 }
43552
43553
43554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43555   void * jresult ;
43556   Dali::Rect< int > *result = 0 ;
43557
43558   {
43559     try {
43560       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43561     } catch (std::out_of_range& e) {
43562       {
43563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43564       };
43565     } catch (std::exception& e) {
43566       {
43567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43568       };
43569     } catch (...) {
43570       {
43571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43572       };
43573     }
43574   }
43575   jresult = (void *)result;
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43581   void * jresult ;
43582   int arg1 ;
43583   int arg2 ;
43584   int arg3 ;
43585   int arg4 ;
43586   Dali::Rect< int > *result = 0 ;
43587
43588   arg1 = (int)jarg1;
43589   arg2 = (int)jarg2;
43590   arg3 = (int)jarg3;
43591   arg4 = (int)jarg4;
43592   {
43593     try {
43594       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43595     } catch (std::out_of_range& e) {
43596       {
43597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43598       };
43599     } catch (std::exception& e) {
43600       {
43601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43602       };
43603     } catch (...) {
43604       {
43605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43606       };
43607     }
43608   }
43609   jresult = (void *)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43615   void * jresult ;
43616   Dali::Rect< int > *arg1 = 0 ;
43617   Dali::Rect< int > *result = 0 ;
43618
43619   arg1 = (Dali::Rect< int > *)jarg1;
43620   if (!arg1) {
43621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43622     return 0;
43623   }
43624   {
43625     try {
43626       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43627     } catch (std::out_of_range& e) {
43628       {
43629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (std::exception& e) {
43632       {
43633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43647   void * jresult ;
43648   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43649   Dali::Rect< int > *arg2 = 0 ;
43650   Dali::Rect< int > *result = 0 ;
43651
43652   arg1 = (Dali::Rect< int > *)jarg1;
43653   arg2 = (Dali::Rect< int > *)jarg2;
43654   if (!arg2) {
43655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43656     return 0;
43657   }
43658   {
43659     try {
43660       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43661     } catch (std::out_of_range& e) {
43662       {
43663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43664       };
43665     } catch (std::exception& e) {
43666       {
43667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43668       };
43669     } catch (...) {
43670       {
43671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43672       };
43673     }
43674   }
43675   jresult = (void *)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43681   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43682   int arg2 ;
43683   int arg3 ;
43684   int arg4 ;
43685   int arg5 ;
43686
43687   arg1 = (Dali::Rect< int > *)jarg1;
43688   arg2 = (int)jarg2;
43689   arg3 = (int)jarg3;
43690   arg4 = (int)jarg4;
43691   arg5 = (int)jarg5;
43692   {
43693     try {
43694       (arg1)->Set(arg2,arg3,arg4,arg5);
43695     } catch (std::out_of_range& e) {
43696       {
43697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43698       };
43699     } catch (std::exception& e) {
43700       {
43701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43702       };
43703     } catch (...) {
43704       {
43705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43706       };
43707     }
43708   }
43709 }
43710
43711
43712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43713   unsigned int jresult ;
43714   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43715   bool result;
43716
43717   arg1 = (Dali::Rect< int > *)jarg1;
43718   {
43719     try {
43720       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43721     } catch (std::out_of_range& e) {
43722       {
43723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (std::exception& e) {
43726       {
43727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43732       };
43733     }
43734   }
43735   jresult = result;
43736   return jresult;
43737 }
43738
43739
43740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43741   int jresult ;
43742   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43743   int result;
43744
43745   arg1 = (Dali::Rect< int > *)jarg1;
43746   {
43747     try {
43748       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43749     } catch (std::out_of_range& e) {
43750       {
43751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43752       };
43753     } catch (std::exception& e) {
43754       {
43755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43760       };
43761     }
43762   }
43763   jresult = result;
43764   return jresult;
43765 }
43766
43767
43768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43769   int jresult ;
43770   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43771   int result;
43772
43773   arg1 = (Dali::Rect< int > *)jarg1;
43774   {
43775     try {
43776       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43777     } catch (std::out_of_range& e) {
43778       {
43779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43780       };
43781     } catch (std::exception& e) {
43782       {
43783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43784       };
43785     } catch (...) {
43786       {
43787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43788       };
43789     }
43790   }
43791   jresult = result;
43792   return jresult;
43793 }
43794
43795
43796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43797   int jresult ;
43798   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43799   int result;
43800
43801   arg1 = (Dali::Rect< int > *)jarg1;
43802   {
43803     try {
43804       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43805     } catch (std::out_of_range& e) {
43806       {
43807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43808       };
43809     } catch (std::exception& e) {
43810       {
43811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43812       };
43813     } catch (...) {
43814       {
43815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43816       };
43817     }
43818   }
43819   jresult = result;
43820   return jresult;
43821 }
43822
43823
43824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43825   int jresult ;
43826   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43827   int result;
43828
43829   arg1 = (Dali::Rect< int > *)jarg1;
43830   {
43831     try {
43832       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43833     } catch (std::out_of_range& e) {
43834       {
43835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43836       };
43837     } catch (std::exception& e) {
43838       {
43839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43840       };
43841     } catch (...) {
43842       {
43843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43844       };
43845     }
43846   }
43847   jresult = result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43853   int jresult ;
43854   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43855   int result;
43856
43857   arg1 = (Dali::Rect< int > *)jarg1;
43858   {
43859     try {
43860       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43861     } catch (std::out_of_range& e) {
43862       {
43863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43864       };
43865     } catch (std::exception& e) {
43866       {
43867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43872       };
43873     }
43874   }
43875   jresult = result;
43876   return jresult;
43877 }
43878
43879
43880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43881   unsigned int jresult ;
43882   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43883   Dali::Rect< int > *arg2 = 0 ;
43884   bool result;
43885
43886   arg1 = (Dali::Rect< int > *)jarg1;
43887   arg2 = (Dali::Rect< int > *)jarg2;
43888   if (!arg2) {
43889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43890     return 0;
43891   }
43892   {
43893     try {
43894       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43895     } catch (std::out_of_range& e) {
43896       {
43897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43898       };
43899     } catch (std::exception& e) {
43900       {
43901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43902       };
43903     } catch (...) {
43904       {
43905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43906       };
43907     }
43908   }
43909   jresult = result;
43910   return jresult;
43911 }
43912
43913
43914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43915   unsigned int jresult ;
43916   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43917   Dali::Rect< int > *arg2 = 0 ;
43918   bool result;
43919
43920   arg1 = (Dali::Rect< int > *)jarg1;
43921   arg2 = (Dali::Rect< int > *)jarg2;
43922   if (!arg2) {
43923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43924     return 0;
43925   }
43926   {
43927     try {
43928       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43929     } catch (std::out_of_range& e) {
43930       {
43931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43932       };
43933     } catch (std::exception& e) {
43934       {
43935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43936       };
43937     } catch (...) {
43938       {
43939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43940       };
43941     }
43942   }
43943   jresult = result;
43944   return jresult;
43945 }
43946
43947
43948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43949   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43950   int arg2 ;
43951
43952   arg1 = (Dali::Rect< int > *)jarg1;
43953   arg2 = (int)jarg2;
43954   if (arg1) (arg1)->x = arg2;
43955 }
43956
43957
43958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43959   int jresult ;
43960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43961   int result;
43962
43963   arg1 = (Dali::Rect< int > *)jarg1;
43964   result = (int) ((arg1)->x);
43965   jresult = result;
43966   return jresult;
43967 }
43968
43969
43970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43971   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43972   int arg2 ;
43973
43974   arg1 = (Dali::Rect< int > *)jarg1;
43975   arg2 = (int)jarg2;
43976   if (arg1) (arg1)->left = arg2;
43977 }
43978
43979
43980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43981   int jresult ;
43982   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43983   int result;
43984
43985   arg1 = (Dali::Rect< int > *)jarg1;
43986   result = (int) ((arg1)->left);
43987   jresult = result;
43988   return jresult;
43989 }
43990
43991
43992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43993   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43994   int arg2 ;
43995
43996   arg1 = (Dali::Rect< int > *)jarg1;
43997   arg2 = (int)jarg2;
43998   if (arg1) (arg1)->y = arg2;
43999 }
44000
44001
44002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44003   int jresult ;
44004   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44005   int result;
44006
44007   arg1 = (Dali::Rect< int > *)jarg1;
44008   result = (int) ((arg1)->y);
44009   jresult = result;
44010   return jresult;
44011 }
44012
44013
44014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44015   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44016   int arg2 ;
44017
44018   arg1 = (Dali::Rect< int > *)jarg1;
44019   arg2 = (int)jarg2;
44020   if (arg1) (arg1)->right = arg2;
44021 }
44022
44023
44024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44025   int jresult ;
44026   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44027   int result;
44028
44029   arg1 = (Dali::Rect< int > *)jarg1;
44030   result = (int) ((arg1)->right);
44031   jresult = result;
44032   return jresult;
44033 }
44034
44035
44036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44037   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44038   int arg2 ;
44039
44040   arg1 = (Dali::Rect< int > *)jarg1;
44041   arg2 = (int)jarg2;
44042   if (arg1) (arg1)->width = arg2;
44043 }
44044
44045
44046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44047   int jresult ;
44048   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44049   int result;
44050
44051   arg1 = (Dali::Rect< int > *)jarg1;
44052   result = (int) ((arg1)->width);
44053   jresult = result;
44054   return jresult;
44055 }
44056
44057
44058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44060   int arg2 ;
44061
44062   arg1 = (Dali::Rect< int > *)jarg1;
44063   arg2 = (int)jarg2;
44064   if (arg1) (arg1)->bottom = arg2;
44065 }
44066
44067
44068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44069   int jresult ;
44070   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44071   int result;
44072
44073   arg1 = (Dali::Rect< int > *)jarg1;
44074   result = (int) ((arg1)->bottom);
44075   jresult = result;
44076   return jresult;
44077 }
44078
44079
44080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44081   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44082   int arg2 ;
44083
44084   arg1 = (Dali::Rect< int > *)jarg1;
44085   arg2 = (int)jarg2;
44086   if (arg1) (arg1)->height = arg2;
44087 }
44088
44089
44090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44091   int jresult ;
44092   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44093   int result;
44094
44095   arg1 = (Dali::Rect< int > *)jarg1;
44096   result = (int) ((arg1)->height);
44097   jresult = result;
44098   return jresult;
44099 }
44100
44101
44102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44103   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44104   int arg2 ;
44105
44106   arg1 = (Dali::Rect< int > *)jarg1;
44107   arg2 = (int)jarg2;
44108   if (arg1) (arg1)->top = arg2;
44109 }
44110
44111
44112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44113   int jresult ;
44114   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44115   int result;
44116
44117   arg1 = (Dali::Rect< int > *)jarg1;
44118   result = (int) ((arg1)->top);
44119   jresult = result;
44120   return jresult;
44121 }
44122
44123
44124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44125   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44126
44127   arg1 = (Dali::Rect< int > *)jarg1;
44128   {
44129     try {
44130       delete arg1;
44131     } catch (std::out_of_range& e) {
44132       {
44133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44134       };
44135     } catch (std::exception& e) {
44136       {
44137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44138       };
44139     } catch (...) {
44140       {
44141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44142       };
44143     }
44144   }
44145 }
44146
44147
44148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44149   void * jresult ;
44150   Dali::Rect< float > *result = 0 ;
44151
44152   {
44153     try {
44154       result = (Dali::Rect< float > *)new Dali::Rect< float >();
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169   jresult = (void *)result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44175   void * jresult ;
44176   float arg1 ;
44177   float arg2 ;
44178   float arg3 ;
44179   float arg4 ;
44180   Dali::Rect< float > *result = 0 ;
44181
44182   arg1 = (float)jarg1;
44183   arg2 = (float)jarg2;
44184   arg3 = (float)jarg3;
44185   arg4 = (float)jarg4;
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)jarg4;
44285   arg5 = (float)jarg5;
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_x_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)->x = arg2;
44313 }
44314
44315
44316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_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)->x);
44323   jresult = result;
44324   return jresult;
44325 }
44326
44327
44328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_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_left_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_y_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)->y = arg2;
44357 }
44358
44359
44360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_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)->y);
44367   jresult = result;
44368   return jresult;
44369 }
44370
44371
44372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_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_right_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_width_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)->width = arg2;
44401 }
44402
44403
44404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_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)->width);
44411   jresult = result;
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_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)->bottom = arg2;
44423 }
44424
44425
44426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_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)->bottom);
44433   jresult = result;
44434   return jresult;
44435 }
44436
44437
44438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
44439   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44440   float arg2 ;
44441
44442   arg1 = (Dali::Rect< float > *)jarg1;
44443   arg2 = (float)jarg2;
44444   if (arg1) (arg1)->height = arg2;
44445 }
44446
44447
44448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
44449   float jresult ;
44450   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44451   float result;
44452
44453   arg1 = (Dali::Rect< float > *)jarg1;
44454   result = (float) ((arg1)->height);
44455   jresult = result;
44456   return jresult;
44457 }
44458
44459
44460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44461   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44462   float arg2 ;
44463
44464   arg1 = (Dali::Rect< float > *)jarg1;
44465   arg2 = (float)jarg2;
44466   if (arg1) (arg1)->top = arg2;
44467 }
44468
44469
44470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44471   float jresult ;
44472   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44473   float result;
44474
44475   arg1 = (Dali::Rect< float > *)jarg1;
44476   result = (float) ((arg1)->top);
44477   jresult = result;
44478   return jresult;
44479 }
44480
44481
44482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44483   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44484
44485   arg1 = (Dali::Rect< float > *)jarg1;
44486   {
44487     try {
44488       delete arg1;
44489     } catch (std::out_of_range& e) {
44490       {
44491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44492       };
44493     } catch (std::exception& e) {
44494       {
44495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44496       };
44497     } catch (...) {
44498       {
44499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44500       };
44501     }
44502   }
44503 }
44504
44505
44506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44507   int jresult ;
44508   int result;
44509
44510   result = (int)Dali::Vector< int >::BaseType;
44511   jresult = (int)result;
44512   return jresult;
44513 }
44514
44515
44516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44517   void * jresult ;
44518   Dali::Vector< int > *result = 0 ;
44519
44520   {
44521     try {
44522       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44523     } catch (std::out_of_range& e) {
44524       {
44525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44526       };
44527     } catch (std::exception& e) {
44528       {
44529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44530       };
44531     } catch (...) {
44532       {
44533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44534       };
44535     }
44536   }
44537   jresult = (void *)result;
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44543   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44544
44545   arg1 = (Dali::Vector< int > *)jarg1;
44546   {
44547     try {
44548       delete arg1;
44549     } catch (std::out_of_range& e) {
44550       {
44551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44552       };
44553     } catch (std::exception& e) {
44554       {
44555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44556       };
44557     } catch (...) {
44558       {
44559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44560       };
44561     }
44562   }
44563 }
44564
44565
44566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44567   void * jresult ;
44568   Dali::Vector< int > *arg1 = 0 ;
44569   Dali::Vector< int > *result = 0 ;
44570
44571   arg1 = (Dali::Vector< int > *)jarg1;
44572   if (!arg1) {
44573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44574     return 0;
44575   }
44576   {
44577     try {
44578       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44579     } catch (std::out_of_range& e) {
44580       {
44581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44582       };
44583     } catch (std::exception& e) {
44584       {
44585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (...) {
44588       {
44589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44590       };
44591     }
44592   }
44593   jresult = (void *)result;
44594   return jresult;
44595 }
44596
44597
44598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44599   void * jresult ;
44600   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44601   Dali::Vector< int > *arg2 = 0 ;
44602   Dali::Vector< int > *result = 0 ;
44603
44604   arg1 = (Dali::Vector< int > *)jarg1;
44605   arg2 = (Dali::Vector< int > *)jarg2;
44606   if (!arg2) {
44607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44608     return 0;
44609   }
44610   {
44611     try {
44612       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44613     } catch (std::out_of_range& e) {
44614       {
44615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44616       };
44617     } catch (std::exception& e) {
44618       {
44619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44620       };
44621     } catch (...) {
44622       {
44623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44624       };
44625     }
44626   }
44627   jresult = (void *)result;
44628   return jresult;
44629 }
44630
44631
44632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44633   void * jresult ;
44634   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44635   Dali::Vector< int >::Iterator result;
44636
44637   arg1 = (Dali::Vector< int > *)jarg1;
44638   {
44639     try {
44640       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44641     } catch (std::out_of_range& e) {
44642       {
44643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44644       };
44645     } catch (std::exception& e) {
44646       {
44647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44648       };
44649     } catch (...) {
44650       {
44651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44652       };
44653     }
44654   }
44655   jresult = (void *)result;
44656   return jresult;
44657 }
44658
44659
44660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44661   void * jresult ;
44662   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44663   Dali::Vector< int >::Iterator result;
44664
44665   arg1 = (Dali::Vector< int > *)jarg1;
44666   {
44667     try {
44668       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44676       };
44677     } catch (...) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44680       };
44681     }
44682   }
44683   jresult = (void *)result;
44684   return jresult;
44685 }
44686
44687
44688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44689   void * jresult ;
44690   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44691   Dali::Vector< int >::SizeType arg2 ;
44692   Dali::Vector< int >::ItemType *result = 0 ;
44693
44694   arg1 = (Dali::Vector< int > *)jarg1;
44695   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44696   {
44697     try {
44698       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44710       };
44711     }
44712   }
44713   jresult = (void *)result;
44714   return jresult;
44715 }
44716
44717
44718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44719   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44720   Dali::Vector< int >::ItemType *arg2 = 0 ;
44721   Dali::Vector< int >::ItemType temp2 ;
44722
44723   arg1 = (Dali::Vector< int > *)jarg1;
44724   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44725   arg2 = &temp2;
44726   {
44727     try {
44728       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44729     } catch (std::out_of_range& e) {
44730       {
44731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44732       };
44733     } catch (std::exception& e) {
44734       {
44735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44736       };
44737     } catch (...) {
44738       {
44739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44740       };
44741     }
44742   }
44743 }
44744
44745
44746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44747   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44748   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44749   Dali::Vector< int >::ItemType *arg3 = 0 ;
44750   Dali::Vector< int >::ItemType temp3 ;
44751
44752   arg1 = (Dali::Vector< int > *)jarg1;
44753   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44754   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44755   arg3 = &temp3;
44756   {
44757     try {
44758       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44766       };
44767     } catch (...) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44770       };
44771     }
44772   }
44773 }
44774
44775
44776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44777   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44778   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44779   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44780   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44781
44782   arg1 = (Dali::Vector< int > *)jarg1;
44783   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44784   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44785   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44786   {
44787     try {
44788       (arg1)->Insert(arg2,arg3,arg4);
44789     } catch (std::out_of_range& e) {
44790       {
44791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44792       };
44793     } catch (std::exception& e) {
44794       {
44795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44796       };
44797     } catch (...) {
44798       {
44799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44800       };
44801     }
44802   }
44803 }
44804
44805
44806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44807   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44808   Dali::Vector< int >::SizeType arg2 ;
44809
44810   arg1 = (Dali::Vector< int > *)jarg1;
44811   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44812   {
44813     try {
44814       (arg1)->Reserve(arg2);
44815     } catch (std::out_of_range& e) {
44816       {
44817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44818       };
44819     } catch (std::exception& e) {
44820       {
44821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44822       };
44823     } catch (...) {
44824       {
44825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44826       };
44827     }
44828   }
44829 }
44830
44831
44832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44833   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44834   Dali::Vector< int >::SizeType arg2 ;
44835
44836   arg1 = (Dali::Vector< int > *)jarg1;
44837   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44838   {
44839     try {
44840       (arg1)->Resize(arg2);
44841     } catch (std::out_of_range& e) {
44842       {
44843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44844       };
44845     } catch (std::exception& e) {
44846       {
44847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44848       };
44849     } catch (...) {
44850       {
44851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44852       };
44853     }
44854   }
44855 }
44856
44857
44858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44859   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44860   Dali::Vector< int >::SizeType arg2 ;
44861   Dali::Vector< int >::ItemType *arg3 = 0 ;
44862   Dali::Vector< int >::ItemType temp3 ;
44863
44864   arg1 = (Dali::Vector< int > *)jarg1;
44865   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44866   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44867   arg3 = &temp3;
44868   {
44869     try {
44870       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44871     } catch (std::out_of_range& e) {
44872       {
44873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44874       };
44875     } catch (std::exception& e) {
44876       {
44877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44878       };
44879     } catch (...) {
44880       {
44881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44882       };
44883     }
44884   }
44885 }
44886
44887
44888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44889   void * jresult ;
44890   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44891   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44892   Dali::Vector< int >::Iterator result;
44893
44894   arg1 = (Dali::Vector< int > *)jarg1;
44895   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44896   {
44897     try {
44898       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44899     } catch (std::out_of_range& e) {
44900       {
44901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44902       };
44903     } catch (std::exception& e) {
44904       {
44905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44906       };
44907     } catch (...) {
44908       {
44909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44910       };
44911     }
44912   }
44913   jresult = (void *)result;
44914   return jresult;
44915 }
44916
44917
44918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44919   void * jresult ;
44920   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44921   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44922   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44923   Dali::Vector< int >::Iterator result;
44924
44925   arg1 = (Dali::Vector< int > *)jarg1;
44926   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44927   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44928   {
44929     try {
44930       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44931     } catch (std::out_of_range& e) {
44932       {
44933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44934       };
44935     } catch (std::exception& e) {
44936       {
44937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44938       };
44939     } catch (...) {
44940       {
44941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44942       };
44943     }
44944   }
44945   jresult = (void *)result;
44946   return jresult;
44947 }
44948
44949
44950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44951   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44952   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44953
44954   arg1 = (Dali::Vector< int > *)jarg1;
44955   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44956   {
44957     try {
44958       (arg1)->Remove(arg2);
44959     } catch (std::out_of_range& e) {
44960       {
44961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44962       };
44963     } catch (std::exception& e) {
44964       {
44965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44966       };
44967     } catch (...) {
44968       {
44969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44970       };
44971     }
44972   }
44973 }
44974
44975
44976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44977   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44978   Dali::Vector< int > *arg2 = 0 ;
44979
44980   arg1 = (Dali::Vector< int > *)jarg1;
44981   arg2 = (Dali::Vector< int > *)jarg2;
44982   if (!arg2) {
44983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44984     return ;
44985   }
44986   {
44987     try {
44988       (arg1)->Swap(*arg2);
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45000       };
45001     }
45002   }
45003 }
45004
45005
45006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
45007   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
45008
45009   arg1 = (Dali::Vector< int > *)jarg1;
45010   {
45011     try {
45012       (arg1)->Clear();
45013     } catch (std::out_of_range& e) {
45014       {
45015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45016       };
45017     } catch (std::exception& e) {
45018       {
45019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45020       };
45021     } catch (...) {
45022       {
45023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45024       };
45025     }
45026   }
45027 }
45028
45029
45030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
45031   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
45032
45033   arg1 = (Dali::Vector< int > *)jarg1;
45034   {
45035     try {
45036       (arg1)->Release();
45037     } catch (std::out_of_range& e) {
45038       {
45039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45040       };
45041     } catch (std::exception& e) {
45042       {
45043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45044       };
45045     } catch (...) {
45046       {
45047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45048       };
45049     }
45050   }
45051 }
45052
45053
45054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45055   int jresult ;
45056   int result;
45057
45058   result = (int)Dali::Vector< float >::BaseType;
45059   jresult = (int)result;
45060   return jresult;
45061 }
45062
45063
45064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45065   void * jresult ;
45066   Dali::Vector< float > *result = 0 ;
45067
45068   {
45069     try {
45070       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45071     } catch (std::out_of_range& e) {
45072       {
45073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45074       };
45075     } catch (std::exception& e) {
45076       {
45077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45078       };
45079     } catch (...) {
45080       {
45081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45082       };
45083     }
45084   }
45085   jresult = (void *)result;
45086   return jresult;
45087 }
45088
45089
45090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45091   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45092
45093   arg1 = (Dali::Vector< float > *)jarg1;
45094   {
45095     try {
45096       delete arg1;
45097     } catch (std::out_of_range& e) {
45098       {
45099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45100       };
45101     } catch (std::exception& e) {
45102       {
45103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45104       };
45105     } catch (...) {
45106       {
45107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45108       };
45109     }
45110   }
45111 }
45112
45113
45114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45115   void * jresult ;
45116   Dali::Vector< float > *arg1 = 0 ;
45117   Dali::Vector< float > *result = 0 ;
45118
45119   arg1 = (Dali::Vector< float > *)jarg1;
45120   if (!arg1) {
45121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45122     return 0;
45123   }
45124   {
45125     try {
45126       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141   jresult = (void *)result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45147   void * jresult ;
45148   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45149   Dali::Vector< float > *arg2 = 0 ;
45150   Dali::Vector< float > *result = 0 ;
45151
45152   arg1 = (Dali::Vector< float > *)jarg1;
45153   arg2 = (Dali::Vector< float > *)jarg2;
45154   if (!arg2) {
45155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45156     return 0;
45157   }
45158   {
45159     try {
45160       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45161     } catch (std::out_of_range& e) {
45162       {
45163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45164       };
45165     } catch (std::exception& e) {
45166       {
45167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45168       };
45169     } catch (...) {
45170       {
45171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45172       };
45173     }
45174   }
45175   jresult = (void *)result;
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45181   void * jresult ;
45182   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45183   Dali::Vector< float >::Iterator result;
45184
45185   arg1 = (Dali::Vector< float > *)jarg1;
45186   {
45187     try {
45188       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45189     } catch (std::out_of_range& e) {
45190       {
45191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45192       };
45193     } catch (std::exception& e) {
45194       {
45195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45196       };
45197     } catch (...) {
45198       {
45199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45200       };
45201     }
45202   }
45203   jresult = (void *)result;
45204   return jresult;
45205 }
45206
45207
45208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45209   void * jresult ;
45210   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45211   Dali::Vector< float >::Iterator result;
45212
45213   arg1 = (Dali::Vector< float > *)jarg1;
45214   {
45215     try {
45216       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45217     } catch (std::out_of_range& e) {
45218       {
45219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45220       };
45221     } catch (std::exception& e) {
45222       {
45223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45224       };
45225     } catch (...) {
45226       {
45227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45228       };
45229     }
45230   }
45231   jresult = (void *)result;
45232   return jresult;
45233 }
45234
45235
45236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45237   void * jresult ;
45238   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45239   Dali::Vector< float >::SizeType arg2 ;
45240   Dali::Vector< float >::ItemType *result = 0 ;
45241
45242   arg1 = (Dali::Vector< float > *)jarg1;
45243   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45244   {
45245     try {
45246       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45247     } catch (std::out_of_range& e) {
45248       {
45249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45250       };
45251     } catch (std::exception& e) {
45252       {
45253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45254       };
45255     } catch (...) {
45256       {
45257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45258       };
45259     }
45260   }
45261   jresult = (void *)result;
45262   return jresult;
45263 }
45264
45265
45266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45267   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45268   Dali::Vector< float >::ItemType *arg2 = 0 ;
45269   Dali::Vector< float >::ItemType temp2 ;
45270
45271   arg1 = (Dali::Vector< float > *)jarg1;
45272   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45273   arg2 = &temp2;
45274   {
45275     try {
45276       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45277     } catch (std::out_of_range& e) {
45278       {
45279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45280       };
45281     } catch (std::exception& e) {
45282       {
45283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (...) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45288       };
45289     }
45290   }
45291 }
45292
45293
45294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45295   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45296   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45297   Dali::Vector< float >::ItemType *arg3 = 0 ;
45298   Dali::Vector< float >::ItemType temp3 ;
45299
45300   arg1 = (Dali::Vector< float > *)jarg1;
45301   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45302   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45303   arg3 = &temp3;
45304   {
45305     try {
45306       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45307     } catch (std::out_of_range& e) {
45308       {
45309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45310       };
45311     } catch (std::exception& e) {
45312       {
45313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45314       };
45315     } catch (...) {
45316       {
45317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45318       };
45319     }
45320   }
45321 }
45322
45323
45324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45325   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45326   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45327   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45328   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45329
45330   arg1 = (Dali::Vector< float > *)jarg1;
45331   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45332   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45333   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45334   {
45335     try {
45336       (arg1)->Insert(arg2,arg3,arg4);
45337     } catch (std::out_of_range& e) {
45338       {
45339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45340       };
45341     } catch (std::exception& e) {
45342       {
45343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45344       };
45345     } catch (...) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45348       };
45349     }
45350   }
45351 }
45352
45353
45354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45355   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45356   Dali::Vector< float >::SizeType arg2 ;
45357
45358   arg1 = (Dali::Vector< float > *)jarg1;
45359   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45360   {
45361     try {
45362       (arg1)->Reserve(arg2);
45363     } catch (std::out_of_range& e) {
45364       {
45365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45366       };
45367     } catch (std::exception& e) {
45368       {
45369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45370       };
45371     } catch (...) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45374       };
45375     }
45376   }
45377 }
45378
45379
45380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45381   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45382   Dali::Vector< float >::SizeType arg2 ;
45383
45384   arg1 = (Dali::Vector< float > *)jarg1;
45385   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45386   {
45387     try {
45388       (arg1)->Resize(arg2);
45389     } catch (std::out_of_range& e) {
45390       {
45391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45392       };
45393     } catch (std::exception& e) {
45394       {
45395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45396       };
45397     } catch (...) {
45398       {
45399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45400       };
45401     }
45402   }
45403 }
45404
45405
45406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45407   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45408   Dali::Vector< float >::SizeType arg2 ;
45409   Dali::Vector< float >::ItemType *arg3 = 0 ;
45410   Dali::Vector< float >::ItemType temp3 ;
45411
45412   arg1 = (Dali::Vector< float > *)jarg1;
45413   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45414   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45415   arg3 = &temp3;
45416   {
45417     try {
45418       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45419     } catch (std::out_of_range& e) {
45420       {
45421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45422       };
45423     } catch (std::exception& e) {
45424       {
45425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45426       };
45427     } catch (...) {
45428       {
45429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45430       };
45431     }
45432   }
45433 }
45434
45435
45436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45437   void * jresult ;
45438   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45439   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45440   Dali::Vector< float >::Iterator result;
45441
45442   arg1 = (Dali::Vector< float > *)jarg1;
45443   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45444   {
45445     try {
45446       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45447     } catch (std::out_of_range& e) {
45448       {
45449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45450       };
45451     } catch (std::exception& e) {
45452       {
45453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45454       };
45455     } catch (...) {
45456       {
45457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45458       };
45459     }
45460   }
45461   jresult = (void *)result;
45462   return jresult;
45463 }
45464
45465
45466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45467   void * jresult ;
45468   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45469   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45470   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45471   Dali::Vector< float >::Iterator result;
45472
45473   arg1 = (Dali::Vector< float > *)jarg1;
45474   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45475   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45476   {
45477     try {
45478       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45479     } catch (std::out_of_range& e) {
45480       {
45481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45482       };
45483     } catch (std::exception& e) {
45484       {
45485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45486       };
45487     } catch (...) {
45488       {
45489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45490       };
45491     }
45492   }
45493   jresult = (void *)result;
45494   return jresult;
45495 }
45496
45497
45498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45499   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45500   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45501
45502   arg1 = (Dali::Vector< float > *)jarg1;
45503   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45504   {
45505     try {
45506       (arg1)->Remove(arg2);
45507     } catch (std::out_of_range& e) {
45508       {
45509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45510       };
45511     } catch (std::exception& e) {
45512       {
45513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45514       };
45515     } catch (...) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45518       };
45519     }
45520   }
45521 }
45522
45523
45524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45525   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45526   Dali::Vector< float > *arg2 = 0 ;
45527
45528   arg1 = (Dali::Vector< float > *)jarg1;
45529   arg2 = (Dali::Vector< float > *)jarg2;
45530   if (!arg2) {
45531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45532     return ;
45533   }
45534   {
45535     try {
45536       (arg1)->Swap(*arg2);
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45548       };
45549     }
45550   }
45551 }
45552
45553
45554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45555   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45556
45557   arg1 = (Dali::Vector< float > *)jarg1;
45558   {
45559     try {
45560       (arg1)->Clear();
45561     } catch (std::out_of_range& e) {
45562       {
45563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45564       };
45565     } catch (std::exception& e) {
45566       {
45567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45568       };
45569     } catch (...) {
45570       {
45571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45572       };
45573     }
45574   }
45575 }
45576
45577
45578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
45579   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45580
45581   arg1 = (Dali::Vector< float > *)jarg1;
45582   {
45583     try {
45584       (arg1)->Release();
45585     } catch (std::out_of_range& e) {
45586       {
45587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45588       };
45589     } catch (std::exception& e) {
45590       {
45591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45592       };
45593     } catch (...) {
45594       {
45595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45596       };
45597     }
45598   }
45599 }
45600
45601
45602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45603   int jresult ;
45604   int result;
45605
45606   result = (int)Dali::Vector< unsigned char >::BaseType;
45607   jresult = (int)result;
45608   return jresult;
45609 }
45610
45611
45612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45613   void * jresult ;
45614   Dali::Vector< unsigned char > *result = 0 ;
45615
45616   {
45617     try {
45618       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45619     } catch (std::out_of_range& e) {
45620       {
45621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45622       };
45623     } catch (std::exception& e) {
45624       {
45625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45626       };
45627     } catch (...) {
45628       {
45629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45630       };
45631     }
45632   }
45633   jresult = (void *)result;
45634   return jresult;
45635 }
45636
45637
45638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45639   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45640
45641   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45642   {
45643     try {
45644       delete arg1;
45645     } catch (std::out_of_range& e) {
45646       {
45647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45648       };
45649     } catch (std::exception& e) {
45650       {
45651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45652       };
45653     } catch (...) {
45654       {
45655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45656       };
45657     }
45658   }
45659 }
45660
45661
45662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45663   void * jresult ;
45664   Dali::Vector< unsigned char > *arg1 = 0 ;
45665   Dali::Vector< unsigned char > *result = 0 ;
45666
45667   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45668   if (!arg1) {
45669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45670     return 0;
45671   }
45672   {
45673     try {
45674       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
45675     } catch (std::out_of_range& e) {
45676       {
45677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45678       };
45679     } catch (std::exception& e) {
45680       {
45681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (...) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45686       };
45687     }
45688   }
45689   jresult = (void *)result;
45690   return jresult;
45691 }
45692
45693
45694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45695   void * jresult ;
45696   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45697   Dali::Vector< unsigned char > *arg2 = 0 ;
45698   Dali::Vector< unsigned char > *result = 0 ;
45699
45700   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45701   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45702   if (!arg2) {
45703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45704     return 0;
45705   }
45706   {
45707     try {
45708       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
45709     } catch (std::out_of_range& e) {
45710       {
45711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45712       };
45713     } catch (std::exception& e) {
45714       {
45715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45716       };
45717     } catch (...) {
45718       {
45719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45720       };
45721     }
45722   }
45723   jresult = (void *)result;
45724   return jresult;
45725 }
45726
45727
45728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
45729   void * jresult ;
45730   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45731   Dali::Vector< unsigned char >::Iterator result;
45732
45733   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45734   {
45735     try {
45736       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45737     } catch (std::out_of_range& e) {
45738       {
45739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45740       };
45741     } catch (std::exception& e) {
45742       {
45743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45744       };
45745     } catch (...) {
45746       {
45747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45748       };
45749     }
45750   }
45751   jresult = (void *)result;
45752   return jresult;
45753 }
45754
45755
45756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45757   void * jresult ;
45758   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45759   Dali::Vector< unsigned char >::Iterator result;
45760
45761   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45762   {
45763     try {
45764       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45765     } catch (std::out_of_range& e) {
45766       {
45767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (std::exception& e) {
45770       {
45771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779   jresult = (void *)result;
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45785   void * jresult ;
45786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45787   Dali::Vector< unsigned char >::SizeType arg2 ;
45788   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45789
45790   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45791   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45792   {
45793     try {
45794       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45795     } catch (std::out_of_range& e) {
45796       {
45797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45798       };
45799     } catch (std::exception& e) {
45800       {
45801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45802       };
45803     } catch (...) {
45804       {
45805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45806       };
45807     }
45808   }
45809   jresult = (void *)result;
45810   return jresult;
45811 }
45812
45813
45814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45815   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45816   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45817   Dali::Vector< unsigned char >::ItemType temp2 ;
45818
45819   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45820   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45821   arg2 = &temp2;
45822   {
45823     try {
45824       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45832       };
45833     } catch (...) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45836       };
45837     }
45838   }
45839 }
45840
45841
45842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45843   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45844   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45845   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45846   Dali::Vector< unsigned char >::ItemType temp3 ;
45847
45848   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45849   arg2 = jarg2;
45850   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45851   arg3 = &temp3;
45852   {
45853     try {
45854       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45855     } catch (std::out_of_range& e) {
45856       {
45857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45858       };
45859     } catch (std::exception& e) {
45860       {
45861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45862       };
45863     } catch (...) {
45864       {
45865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45866       };
45867     }
45868   }
45869
45870
45871 }
45872
45873
45874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45875   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45876   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45877   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45878   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45879
45880   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45881   arg2 = jarg2;
45882   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45883   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45884   {
45885     try {
45886       (arg1)->Insert(arg2,arg3,arg4);
45887     } catch (std::out_of_range& e) {
45888       {
45889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45890       };
45891     } catch (std::exception& e) {
45892       {
45893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45894       };
45895     } catch (...) {
45896       {
45897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45898       };
45899     }
45900   }
45901
45902
45903 }
45904
45905
45906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45907   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45908   Dali::Vector< unsigned char >::SizeType arg2 ;
45909
45910   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45911   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45912   {
45913     try {
45914       (arg1)->Reserve(arg2);
45915     } catch (std::out_of_range& e) {
45916       {
45917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45918       };
45919     } catch (std::exception& e) {
45920       {
45921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45922       };
45923     } catch (...) {
45924       {
45925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45926       };
45927     }
45928   }
45929 }
45930
45931
45932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45933   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45934   Dali::Vector< unsigned char >::SizeType arg2 ;
45935
45936   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45937   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45938   {
45939     try {
45940       (arg1)->Resize(arg2);
45941     } catch (std::out_of_range& e) {
45942       {
45943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45944       };
45945     } catch (std::exception& e) {
45946       {
45947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45948       };
45949     } catch (...) {
45950       {
45951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45952       };
45953     }
45954   }
45955 }
45956
45957
45958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45959   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45960   Dali::Vector< unsigned char >::SizeType arg2 ;
45961   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45962   Dali::Vector< unsigned char >::ItemType temp3 ;
45963
45964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45965   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45966   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45967   arg3 = &temp3;
45968   {
45969     try {
45970       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45971     } catch (std::out_of_range& e) {
45972       {
45973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45974       };
45975     } catch (std::exception& e) {
45976       {
45977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45978       };
45979     } catch (...) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45982       };
45983     }
45984   }
45985 }
45986
45987
45988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45989   void * jresult ;
45990   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45991   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45992   Dali::Vector< unsigned char >::Iterator result;
45993
45994   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45995   arg2 = jarg2;
45996   {
45997     try {
45998       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45999     } catch (std::out_of_range& e) {
46000       {
46001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46002       };
46003     } catch (std::exception& e) {
46004       {
46005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46006       };
46007     } catch (...) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46010       };
46011     }
46012   }
46013   jresult = (void *)result;
46014
46015
46016   return jresult;
46017 }
46018
46019
46020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
46021   void * jresult ;
46022   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46023   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46024   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46025   Dali::Vector< unsigned char >::Iterator result;
46026
46027   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46028   arg2 = jarg2;
46029   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
46030   {
46031     try {
46032       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
46033     } catch (std::out_of_range& e) {
46034       {
46035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46036       };
46037     } catch (std::exception& e) {
46038       {
46039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (...) {
46042       {
46043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46044       };
46045     }
46046   }
46047   jresult = (void *)result;
46048
46049
46050   return jresult;
46051 }
46052
46053
46054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46055   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46056   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46057
46058   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46059   arg2 = jarg2;
46060   {
46061     try {
46062       (arg1)->Remove(arg2);
46063     } catch (std::out_of_range& e) {
46064       {
46065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46066       };
46067     } catch (std::exception& e) {
46068       {
46069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46074       };
46075     }
46076   }
46077
46078
46079 }
46080
46081
46082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46083   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46084   Dali::Vector< unsigned char > *arg2 = 0 ;
46085
46086   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46087   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46088   if (!arg2) {
46089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46090     return ;
46091   }
46092   {
46093     try {
46094       (arg1)->Swap(*arg2);
46095     } catch (std::out_of_range& e) {
46096       {
46097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46098       };
46099     } catch (std::exception& e) {
46100       {
46101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46102       };
46103     } catch (...) {
46104       {
46105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46106       };
46107     }
46108   }
46109 }
46110
46111
46112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46113   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46114
46115   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46116   {
46117     try {
46118       (arg1)->Clear();
46119     } catch (std::out_of_range& e) {
46120       {
46121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46122       };
46123     } catch (std::exception& e) {
46124       {
46125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46126       };
46127     } catch (...) {
46128       {
46129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46130       };
46131     }
46132   }
46133 }
46134
46135
46136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46137   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46138
46139   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46140   {
46141     try {
46142       (arg1)->Release();
46143     } catch (std::out_of_range& e) {
46144       {
46145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46146       };
46147     } catch (std::exception& e) {
46148       {
46149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46150       };
46151     } catch (...) {
46152       {
46153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46154       };
46155     }
46156   }
46157 }
46158
46159
46160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46161   int jresult ;
46162   int result;
46163
46164   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46165   jresult = (int)result;
46166   return jresult;
46167 }
46168
46169
46170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46171   void * jresult ;
46172   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46173
46174   {
46175     try {
46176       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46177     } catch (std::out_of_range& e) {
46178       {
46179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46180       };
46181     } catch (std::exception& e) {
46182       {
46183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46184       };
46185     } catch (...) {
46186       {
46187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46188       };
46189     }
46190   }
46191   jresult = (void *)result;
46192   return jresult;
46193 }
46194
46195
46196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46197   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46198
46199   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46200   {
46201     try {
46202       delete arg1;
46203     } catch (std::out_of_range& e) {
46204       {
46205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46206       };
46207     } catch (std::exception& e) {
46208       {
46209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46210       };
46211     } catch (...) {
46212       {
46213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46214       };
46215     }
46216   }
46217 }
46218
46219
46220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46221   void * jresult ;
46222   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46223   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46224
46225   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46226   if (!arg1) {
46227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46228     return 0;
46229   }
46230   {
46231     try {
46232       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46233     } catch (std::out_of_range& e) {
46234       {
46235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46236       };
46237     } catch (std::exception& e) {
46238       {
46239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46240       };
46241     } catch (...) {
46242       {
46243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46244       };
46245     }
46246   }
46247   jresult = (void *)result;
46248   return jresult;
46249 }
46250
46251
46252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46253   void * jresult ;
46254   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46255   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46256   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46257
46258   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46259   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46260   if (!arg2) {
46261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46262     return 0;
46263   }
46264   {
46265     try {
46266       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46267     } catch (std::out_of_range& e) {
46268       {
46269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46270       };
46271     } catch (std::exception& e) {
46272       {
46273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (...) {
46276       {
46277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46278       };
46279     }
46280   }
46281   jresult = (void *)result;
46282   return jresult;
46283 }
46284
46285
46286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46287   void * jresult ;
46288   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46289   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46290
46291   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46292   {
46293     try {
46294       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46295     } catch (std::out_of_range& e) {
46296       {
46297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46298       };
46299     } catch (std::exception& e) {
46300       {
46301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46302       };
46303     } catch (...) {
46304       {
46305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46306       };
46307     }
46308   }
46309   jresult = (void *)result;
46310   return jresult;
46311 }
46312
46313
46314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46315   void * jresult ;
46316   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46317   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46318
46319   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46320   {
46321     try {
46322       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
46323     } catch (std::out_of_range& e) {
46324       {
46325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46326       };
46327     } catch (std::exception& e) {
46328       {
46329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46330       };
46331     } catch (...) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46334       };
46335     }
46336   }
46337   jresult = (void *)result;
46338   return jresult;
46339 }
46340
46341
46342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46343   void * jresult ;
46344   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46345   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46346   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46347
46348   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46349   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46350   {
46351     try {
46352       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46353     } catch (std::out_of_range& e) {
46354       {
46355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46356       };
46357     } catch (std::exception& e) {
46358       {
46359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46360       };
46361     } catch (...) {
46362       {
46363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46364       };
46365     }
46366   }
46367   jresult = (void *)result;
46368   return jresult;
46369 }
46370
46371
46372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46374   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46375
46376   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46377   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46378   if (!arg2) {
46379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46380     return ;
46381   }
46382   {
46383     try {
46384       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46385     } catch (std::out_of_range& e) {
46386       {
46387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46388       };
46389     } catch (std::exception& e) {
46390       {
46391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46392       };
46393     } catch (...) {
46394       {
46395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46396       };
46397     }
46398   }
46399 }
46400
46401
46402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46403   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46404   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46405   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46406
46407   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46408   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46409   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46410   if (!arg3) {
46411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46412     return ;
46413   }
46414   {
46415     try {
46416       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46417     } catch (std::out_of_range& e) {
46418       {
46419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46420       };
46421     } catch (std::exception& e) {
46422       {
46423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46424       };
46425     } catch (...) {
46426       {
46427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46428       };
46429     }
46430   }
46431 }
46432
46433
46434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46435   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46436   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46437   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46438   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46439
46440   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46441   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46442   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46443   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46444   {
46445     try {
46446       (arg1)->Insert(arg2,arg3,arg4);
46447     } catch (std::out_of_range& e) {
46448       {
46449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46450       };
46451     } catch (std::exception& e) {
46452       {
46453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46454       };
46455     } catch (...) {
46456       {
46457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46458       };
46459     }
46460   }
46461 }
46462
46463
46464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46465   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46466   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46467
46468   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46469   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46470   {
46471     try {
46472       (arg1)->Reserve(arg2);
46473     } catch (std::out_of_range& e) {
46474       {
46475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46476       };
46477     } catch (std::exception& e) {
46478       {
46479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46480       };
46481     } catch (...) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46484       };
46485     }
46486   }
46487 }
46488
46489
46490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46491   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46492   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46493
46494   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46495   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46496   {
46497     try {
46498       (arg1)->Resize(arg2);
46499     } catch (std::out_of_range& e) {
46500       {
46501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46502       };
46503     } catch (std::exception& e) {
46504       {
46505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46506       };
46507     } catch (...) {
46508       {
46509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46510       };
46511     }
46512   }
46513 }
46514
46515
46516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46517   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46518   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46519   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46520
46521   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46522   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46523   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46524   if (!arg3) {
46525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46526     return ;
46527   }
46528   {
46529     try {
46530       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46531     } catch (std::out_of_range& e) {
46532       {
46533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46534       };
46535     } catch (std::exception& e) {
46536       {
46537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46538       };
46539     } catch (...) {
46540       {
46541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46542       };
46543     }
46544   }
46545 }
46546
46547
46548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46549   void * jresult ;
46550   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46551   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46552   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46553
46554   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46555   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46556   {
46557     try {
46558       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46559     } catch (std::out_of_range& e) {
46560       {
46561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46562       };
46563     } catch (std::exception& e) {
46564       {
46565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46566       };
46567     } catch (...) {
46568       {
46569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46570       };
46571     }
46572   }
46573   jresult = (void *)result;
46574   return jresult;
46575 }
46576
46577
46578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46579   void * jresult ;
46580   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46581   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46582   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46583   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46584
46585   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46586   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46587   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46588   {
46589     try {
46590       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
46591     } catch (std::out_of_range& e) {
46592       {
46593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46594       };
46595     } catch (std::exception& e) {
46596       {
46597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46598       };
46599     } catch (...) {
46600       {
46601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46602       };
46603     }
46604   }
46605   jresult = (void *)result;
46606   return jresult;
46607 }
46608
46609
46610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46611   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46612   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46613
46614   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46615   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46616   {
46617     try {
46618       (arg1)->Remove(arg2);
46619     } catch (std::out_of_range& e) {
46620       {
46621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46622       };
46623     } catch (std::exception& e) {
46624       {
46625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46626       };
46627     } catch (...) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46630       };
46631     }
46632   }
46633 }
46634
46635
46636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46637   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46638   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46639
46640   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46641   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46642   if (!arg2) {
46643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46644     return ;
46645   }
46646   {
46647     try {
46648       (arg1)->Swap(*arg2);
46649     } catch (std::out_of_range& e) {
46650       {
46651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46652       };
46653     } catch (std::exception& e) {
46654       {
46655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46656       };
46657     } catch (...) {
46658       {
46659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46660       };
46661     }
46662   }
46663 }
46664
46665
46666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46667   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46668
46669   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46670   {
46671     try {
46672       (arg1)->Clear();
46673     } catch (std::out_of_range& e) {
46674       {
46675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46676       };
46677     } catch (std::exception& e) {
46678       {
46679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46680       };
46681     } catch (...) {
46682       {
46683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46684       };
46685     }
46686   }
46687 }
46688
46689
46690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46691   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46692
46693   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46694   {
46695     try {
46696       (arg1)->Release();
46697     } catch (std::out_of_range& e) {
46698       {
46699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46700       };
46701     } catch (std::exception& e) {
46702       {
46703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46704       };
46705     } catch (...) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46708       };
46709     }
46710   }
46711 }
46712
46713
46714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46715   void * jresult ;
46716   Dali::Signal< void () > *result = 0 ;
46717
46718   {
46719     try {
46720       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46721     } catch (std::out_of_range& e) {
46722       {
46723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46724       };
46725     } catch (std::exception& e) {
46726       {
46727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46728       };
46729     } catch (...) {
46730       {
46731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46732       };
46733     }
46734   }
46735   jresult = (void *)result;
46736   return jresult;
46737 }
46738
46739
46740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46741   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46742
46743   arg1 = (Dali::Signal< void () > *)jarg1;
46744   {
46745     try {
46746       delete arg1;
46747     } catch (std::out_of_range& e) {
46748       {
46749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46750       };
46751     } catch (std::exception& e) {
46752       {
46753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46754       };
46755     } catch (...) {
46756       {
46757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46758       };
46759     }
46760   }
46761 }
46762
46763
46764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46765   unsigned int jresult ;
46766   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46767   bool result;
46768
46769   arg1 = (Dali::Signal< void () > *)jarg1;
46770   {
46771     try {
46772       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46784       };
46785     }
46786   }
46787   jresult = result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46793   unsigned long jresult ;
46794   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46795   std::size_t result;
46796
46797   arg1 = (Dali::Signal< void () > *)jarg1;
46798   {
46799     try {
46800       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46801     } catch (std::out_of_range& e) {
46802       {
46803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (std::exception& e) {
46806       {
46807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46812       };
46813     }
46814   }
46815   jresult = (unsigned long)result;
46816   return jresult;
46817 }
46818
46819
46820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46821   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46822   void (*arg2)() = (void (*)()) 0 ;
46823
46824   arg1 = (Dali::Signal< void () > *)jarg1;
46825   arg2 = (void (*)())jarg2;
46826   {
46827     try {
46828       (arg1)->Connect(arg2);
46829     } catch (std::out_of_range& e) {
46830       {
46831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46832       };
46833     } catch (std::exception& e) {
46834       {
46835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46836       };
46837     } catch (...) {
46838       {
46839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46840       };
46841     }
46842   }
46843 }
46844
46845
46846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46847   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46848   void (*arg2)() = (void (*)()) 0 ;
46849
46850   arg1 = (Dali::Signal< void () > *)jarg1;
46851   arg2 = (void (*)())jarg2;
46852   {
46853     try {
46854       (arg1)->Disconnect(arg2);
46855     } catch (std::out_of_range& e) {
46856       {
46857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46858       };
46859     } catch (std::exception& e) {
46860       {
46861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46862       };
46863     } catch (...) {
46864       {
46865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46866       };
46867     }
46868   }
46869 }
46870
46871
46872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46873   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46874   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46875   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46876
46877   arg1 = (Dali::Signal< void () > *)jarg1;
46878   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46879   arg3 = (Dali::FunctorDelegate *)jarg3;
46880   {
46881     try {
46882       (arg1)->Connect(arg2,arg3);
46883     } catch (std::out_of_range& e) {
46884       {
46885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46886       };
46887     } catch (std::exception& e) {
46888       {
46889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46890       };
46891     } catch (...) {
46892       {
46893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46894       };
46895     }
46896   }
46897 }
46898
46899
46900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
46901   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46902
46903   arg1 = (Dali::Signal< void () > *)jarg1;
46904   {
46905     try {
46906       (arg1)->Emit();
46907     } catch (std::out_of_range& e) {
46908       {
46909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46910       };
46911     } catch (std::exception& e) {
46912       {
46913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46914       };
46915     } catch (...) {
46916       {
46917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46918       };
46919     }
46920   }
46921 }
46922
46923
46924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46925   unsigned int jresult ;
46926   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46927   bool result;
46928
46929   arg1 = (Dali::Signal< void (float) > *)jarg1;
46930   {
46931     try {
46932       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46933     } catch (std::out_of_range& e) {
46934       {
46935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46936       };
46937     } catch (std::exception& e) {
46938       {
46939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46940       };
46941     } catch (...) {
46942       {
46943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46944       };
46945     }
46946   }
46947   jresult = result;
46948   return jresult;
46949 }
46950
46951
46952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46953   unsigned long jresult ;
46954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46955   std::size_t result;
46956
46957   arg1 = (Dali::Signal< void (float) > *)jarg1;
46958   {
46959     try {
46960       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46961     } catch (std::out_of_range& e) {
46962       {
46963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46964       };
46965     } catch (std::exception& e) {
46966       {
46967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46968       };
46969     } catch (...) {
46970       {
46971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46972       };
46973     }
46974   }
46975   jresult = (unsigned long)result;
46976   return jresult;
46977 }
46978
46979
46980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46981   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46982   void (*arg2)(float) = (void (*)(float)) 0 ;
46983
46984   arg1 = (Dali::Signal< void (float) > *)jarg1;
46985   arg2 = (void (*)(float))jarg2;
46986   {
46987     try {
46988       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46989     } catch (std::out_of_range& e) {
46990       {
46991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46992       };
46993     } catch (std::exception& e) {
46994       {
46995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46996       };
46997     } catch (...) {
46998       {
46999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47000       };
47001     }
47002   }
47003 }
47004
47005
47006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
47007   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47008   void (*arg2)(float) = (void (*)(float)) 0 ;
47009
47010   arg1 = (Dali::Signal< void (float) > *)jarg1;
47011   arg2 = (void (*)(float))jarg2;
47012   {
47013     try {
47014       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
47015     } catch (std::out_of_range& e) {
47016       {
47017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47018       };
47019     } catch (std::exception& e) {
47020       {
47021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47022       };
47023     } catch (...) {
47024       {
47025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47026       };
47027     }
47028   }
47029 }
47030
47031
47032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
47033   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47034   float arg2 ;
47035
47036   arg1 = (Dali::Signal< void (float) > *)jarg1;
47037   arg2 = (float)jarg2;
47038   {
47039     try {
47040       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
47041     } catch (std::out_of_range& e) {
47042       {
47043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47044       };
47045     } catch (std::exception& e) {
47046       {
47047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47048       };
47049     } catch (...) {
47050       {
47051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47052       };
47053     }
47054   }
47055 }
47056
47057
47058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47059   void * jresult ;
47060   Dali::Signal< void (float) > *result = 0 ;
47061
47062   {
47063     try {
47064       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47065     } catch (std::out_of_range& e) {
47066       {
47067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47068       };
47069     } catch (std::exception& e) {
47070       {
47071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47072       };
47073     } catch (...) {
47074       {
47075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47076       };
47077     }
47078   }
47079   jresult = (void *)result;
47080   return jresult;
47081 }
47082
47083
47084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47086
47087   arg1 = (Dali::Signal< void (float) > *)jarg1;
47088   {
47089     try {
47090       delete arg1;
47091     } catch (std::out_of_range& e) {
47092       {
47093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47094       };
47095     } catch (std::exception& e) {
47096       {
47097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47098       };
47099     } catch (...) {
47100       {
47101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47102       };
47103     }
47104   }
47105 }
47106
47107
47108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47109   unsigned int jresult ;
47110   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47111   bool result;
47112
47113   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47114   {
47115     try {
47116       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47124       };
47125     } catch (...) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47128       };
47129     }
47130   }
47131   jresult = result;
47132   return jresult;
47133 }
47134
47135
47136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47137   unsigned long jresult ;
47138   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47139   std::size_t result;
47140
47141   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47142   {
47143     try {
47144       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47145     } catch (std::out_of_range& e) {
47146       {
47147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (std::exception& e) {
47150       {
47151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (...) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47156       };
47157     }
47158   }
47159   jresult = (unsigned long)result;
47160   return jresult;
47161 }
47162
47163
47164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47165   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47166   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47167
47168   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47169   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47170   {
47171     try {
47172       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47173     } catch (std::out_of_range& e) {
47174       {
47175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47176       };
47177     } catch (std::exception& e) {
47178       {
47179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47180       };
47181     } catch (...) {
47182       {
47183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47184       };
47185     }
47186   }
47187 }
47188
47189
47190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47191   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47192   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47193
47194   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47195   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47196   {
47197     try {
47198       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47199     } catch (std::out_of_range& e) {
47200       {
47201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47202       };
47203     } catch (std::exception& e) {
47204       {
47205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47206       };
47207     } catch (...) {
47208       {
47209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47210       };
47211     }
47212   }
47213 }
47214
47215
47216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47217   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47218   Dali::BaseHandle arg2 ;
47219   Dali::BaseHandle *argp2 ;
47220
47221   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47222   argp2 = (Dali::BaseHandle *)jarg2;
47223   if (!argp2) {
47224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47225     return ;
47226   }
47227   arg2 = *argp2;
47228   {
47229     try {
47230       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47242       };
47243     }
47244   }
47245 }
47246
47247
47248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47249   void * jresult ;
47250   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47251
47252   {
47253     try {
47254       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47255     } catch (std::out_of_range& e) {
47256       {
47257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47258       };
47259     } catch (std::exception& e) {
47260       {
47261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47262       };
47263     } catch (...) {
47264       {
47265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47266       };
47267     }
47268   }
47269   jresult = (void *)result;
47270   return jresult;
47271 }
47272
47273
47274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47275   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47276
47277   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47278   {
47279     try {
47280       delete arg1;
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47288       };
47289     } catch (...) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47292       };
47293     }
47294   }
47295 }
47296
47297
47298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47299   unsigned int jresult ;
47300   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47301   bool result;
47302
47303   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47304   {
47305     try {
47306       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47307     } catch (std::out_of_range& e) {
47308       {
47309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47310       };
47311     } catch (std::exception& e) {
47312       {
47313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47314       };
47315     } catch (...) {
47316       {
47317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47318       };
47319     }
47320   }
47321   jresult = result;
47322   return jresult;
47323 }
47324
47325
47326 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47327   unsigned long jresult ;
47328   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47329   std::size_t result;
47330
47331   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47332   {
47333     try {
47334       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47335     } catch (std::out_of_range& e) {
47336       {
47337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47338       };
47339     } catch (std::exception& e) {
47340       {
47341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47342       };
47343     } catch (...) {
47344       {
47345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47346       };
47347     }
47348   }
47349   jresult = (unsigned long)result;
47350   return jresult;
47351 }
47352
47353
47354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47355   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47356   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47357
47358   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47359   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47360   {
47361     try {
47362       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47370       };
47371     } catch (...) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47374       };
47375     }
47376   }
47377 }
47378
47379
47380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47381   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47382   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47383
47384   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47385   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47386   {
47387     try {
47388       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47389     } catch (std::out_of_range& e) {
47390       {
47391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47392       };
47393     } catch (std::exception& e) {
47394       {
47395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47396       };
47397     } catch (...) {
47398       {
47399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47400       };
47401     }
47402   }
47403 }
47404
47405
47406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47407   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47408   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47409
47410   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47411   arg2 = (Dali::RefObject *)jarg2;
47412   {
47413     try {
47414       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47415     } catch (std::out_of_range& e) {
47416       {
47417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47418       };
47419     } catch (std::exception& e) {
47420       {
47421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47422       };
47423     } catch (...) {
47424       {
47425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47426       };
47427     }
47428   }
47429 }
47430
47431
47432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47433   void * jresult ;
47434   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47435
47436   {
47437     try {
47438       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47439     } catch (std::out_of_range& e) {
47440       {
47441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47442       };
47443     } catch (std::exception& e) {
47444       {
47445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47446       };
47447     } catch (...) {
47448       {
47449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47450       };
47451     }
47452   }
47453   jresult = (void *)result;
47454   return jresult;
47455 }
47456
47457
47458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47459   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47460
47461   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47462   {
47463     try {
47464       delete arg1;
47465     } catch (std::out_of_range& e) {
47466       {
47467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47468       };
47469     } catch (std::exception& e) {
47470       {
47471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47472       };
47473     } catch (...) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47476       };
47477     }
47478   }
47479 }
47480
47481
47482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47483   unsigned int jresult ;
47484   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47485   bool result;
47486
47487   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47488   {
47489     try {
47490       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47491     } catch (std::out_of_range& e) {
47492       {
47493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47494       };
47495     } catch (std::exception& e) {
47496       {
47497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47498       };
47499     } catch (...) {
47500       {
47501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47502       };
47503     }
47504   }
47505   jresult = result;
47506   return jresult;
47507 }
47508
47509
47510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47511   unsigned long jresult ;
47512   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47513   std::size_t result;
47514
47515   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47516   {
47517     try {
47518       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47519     } catch (std::out_of_range& e) {
47520       {
47521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47522       };
47523     } catch (std::exception& e) {
47524       {
47525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47526       };
47527     } catch (...) {
47528       {
47529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47530       };
47531     }
47532   }
47533   jresult = (unsigned long)result;
47534   return jresult;
47535 }
47536
47537
47538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47539   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47540   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47541
47542   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47543   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47544   {
47545     try {
47546       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47547     } catch (std::out_of_range& e) {
47548       {
47549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47550       };
47551     } catch (std::exception& e) {
47552       {
47553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47554       };
47555     } catch (...) {
47556       {
47557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47558       };
47559     }
47560   }
47561 }
47562
47563
47564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47565   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47566   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47567
47568   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47569   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47570   {
47571     try {
47572       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47573     } catch (std::out_of_range& e) {
47574       {
47575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47576       };
47577     } catch (std::exception& e) {
47578       {
47579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47580       };
47581     } catch (...) {
47582       {
47583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47584       };
47585     }
47586   }
47587 }
47588
47589
47590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47591   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47592   Dali::PropertyNotification *arg2 = 0 ;
47593
47594   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47595   arg2 = (Dali::PropertyNotification *)jarg2;
47596   if (!arg2) {
47597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47598     return ;
47599   }
47600   {
47601     try {
47602       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47603     } catch (std::out_of_range& e) {
47604       {
47605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47606       };
47607     } catch (std::exception& e) {
47608       {
47609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47610       };
47611     } catch (...) {
47612       {
47613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47614       };
47615     }
47616   }
47617 }
47618
47619
47620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47621   void * jresult ;
47622   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47623
47624   {
47625     try {
47626       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47627     } catch (std::out_of_range& e) {
47628       {
47629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47630       };
47631     } catch (std::exception& e) {
47632       {
47633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47634       };
47635     } catch (...) {
47636       {
47637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47638       };
47639     }
47640   }
47641   jresult = (void *)result;
47642   return jresult;
47643 }
47644
47645
47646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47647   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47648
47649   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47650   {
47651     try {
47652       delete arg1;
47653     } catch (std::out_of_range& e) {
47654       {
47655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47656       };
47657     } catch (std::exception& e) {
47658       {
47659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47660       };
47661     } catch (...) {
47662       {
47663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47664       };
47665     }
47666   }
47667 }
47668
47669
47670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47671   unsigned int jresult ;
47672   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47673   bool result;
47674
47675   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47676   {
47677     try {
47678       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47679     } catch (std::out_of_range& e) {
47680       {
47681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47682       };
47683     } catch (std::exception& e) {
47684       {
47685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47686       };
47687     } catch (...) {
47688       {
47689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47690       };
47691     }
47692   }
47693   jresult = result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47699   unsigned long jresult ;
47700   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47701   std::size_t result;
47702
47703   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47704   {
47705     try {
47706       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47707     } catch (std::out_of_range& e) {
47708       {
47709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (std::exception& e) {
47712       {
47713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (...) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47718       };
47719     }
47720   }
47721   jresult = (unsigned long)result;
47722   return jresult;
47723 }
47724
47725
47726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47727   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47728   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47729
47730   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47731   arg2 = (void (*)(Dali::Image))jarg2;
47732   {
47733     try {
47734       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47735     } catch (std::out_of_range& e) {
47736       {
47737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47738       };
47739     } catch (std::exception& e) {
47740       {
47741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47742       };
47743     } catch (...) {
47744       {
47745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47746       };
47747     }
47748   }
47749 }
47750
47751
47752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47753   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47754   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47755
47756   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47757   arg2 = (void (*)(Dali::Image))jarg2;
47758   {
47759     try {
47760       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47761     } catch (std::out_of_range& e) {
47762       {
47763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47764       };
47765     } catch (std::exception& e) {
47766       {
47767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47768       };
47769     } catch (...) {
47770       {
47771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47772       };
47773     }
47774   }
47775 }
47776
47777
47778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47779   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47780   Dali::Image arg2 ;
47781   Dali::Image *argp2 ;
47782
47783   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47784   argp2 = (Dali::Image *)jarg2;
47785   if (!argp2) {
47786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47787     return ;
47788   }
47789   arg2 = *argp2;
47790   {
47791     try {
47792       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47793     } catch (std::out_of_range& e) {
47794       {
47795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47796       };
47797     } catch (std::exception& e) {
47798       {
47799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47800       };
47801     } catch (...) {
47802       {
47803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47804       };
47805     }
47806   }
47807 }
47808
47809
47810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47811   void * jresult ;
47812   Dali::Signal< void (Dali::Image) > *result = 0 ;
47813
47814   {
47815     try {
47816       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47817     } catch (std::out_of_range& e) {
47818       {
47819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (std::exception& e) {
47822       {
47823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47824       };
47825     } catch (...) {
47826       {
47827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47828       };
47829     }
47830   }
47831   jresult = (void *)result;
47832   return jresult;
47833 }
47834
47835
47836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47837   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47838
47839   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47840   {
47841     try {
47842       delete arg1;
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47854       };
47855     }
47856   }
47857 }
47858
47859
47860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47861   void * jresult ;
47862   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47863
47864   {
47865     try {
47866       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47867     } catch (std::out_of_range& e) {
47868       {
47869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47870       };
47871     } catch (std::exception& e) {
47872       {
47873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47874       };
47875     } catch (...) {
47876       {
47877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47878       };
47879     }
47880   }
47881   jresult = (void *)result;
47882   return jresult;
47883 }
47884
47885
47886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47887   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47888
47889   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47890   {
47891     try {
47892       delete arg1;
47893     } catch (std::out_of_range& e) {
47894       {
47895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47896       };
47897     } catch (std::exception& e) {
47898       {
47899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47900       };
47901     } catch (...) {
47902       {
47903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47904       };
47905     }
47906   }
47907 }
47908
47909
47910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47911   unsigned int jresult ;
47912   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47913   bool result;
47914
47915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47916   {
47917     try {
47918       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);
47919     } catch (std::out_of_range& e) {
47920       {
47921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47922       };
47923     } catch (std::exception& e) {
47924       {
47925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47926       };
47927     } catch (...) {
47928       {
47929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47930       };
47931     }
47932   }
47933   jresult = result;
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47939   unsigned long jresult ;
47940   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47941   std::size_t result;
47942
47943   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47944   {
47945     try {
47946       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);
47947     } catch (std::out_of_range& e) {
47948       {
47949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47950       };
47951     } catch (std::exception& e) {
47952       {
47953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47954       };
47955     } catch (...) {
47956       {
47957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47958       };
47959     }
47960   }
47961   jresult = (unsigned long)result;
47962   return jresult;
47963 }
47964
47965
47966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47967   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47968   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47969
47970   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47971   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47972   {
47973     try {
47974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47975     } catch (std::out_of_range& e) {
47976       {
47977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (std::exception& e) {
47980       {
47981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47982       };
47983     } catch (...) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47986       };
47987     }
47988   }
47989 }
47990
47991
47992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47993   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47994   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47995
47996   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47997   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47998   {
47999     try {
48000       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48001     } catch (std::out_of_range& e) {
48002       {
48003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48004       };
48005     } catch (std::exception& e) {
48006       {
48007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48008       };
48009     } catch (...) {
48010       {
48011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48012       };
48013     }
48014   }
48015 }
48016
48017
48018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48019   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48020   Dali::Actor arg2 ;
48021   Dali::LongPressGesture *arg3 = 0 ;
48022   Dali::Actor *argp2 ;
48023
48024   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48025   argp2 = (Dali::Actor *)jarg2;
48026   if (!argp2) {
48027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48028     return ;
48029   }
48030   arg2 = *argp2;
48031   arg3 = (Dali::LongPressGesture *)jarg3;
48032   if (!arg3) {
48033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
48034     return ;
48035   }
48036   {
48037     try {
48038       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
48039     } catch (std::out_of_range& e) {
48040       {
48041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48042       };
48043     } catch (std::exception& e) {
48044       {
48045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48046       };
48047     } catch (...) {
48048       {
48049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48050       };
48051     }
48052   }
48053 }
48054
48055
48056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
48057   void * jresult ;
48058   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48059
48060   {
48061     try {
48062       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48063     } catch (std::out_of_range& e) {
48064       {
48065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48066       };
48067     } catch (std::exception& e) {
48068       {
48069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48070       };
48071     } catch (...) {
48072       {
48073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48074       };
48075     }
48076   }
48077   jresult = (void *)result;
48078   return jresult;
48079 }
48080
48081
48082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48083   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48084
48085   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48086   {
48087     try {
48088       delete arg1;
48089     } catch (std::out_of_range& e) {
48090       {
48091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48092       };
48093     } catch (std::exception& e) {
48094       {
48095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48096       };
48097     } catch (...) {
48098       {
48099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48100       };
48101     }
48102   }
48103 }
48104
48105
48106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48107   unsigned int jresult ;
48108   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48109   bool result;
48110
48111   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48112   {
48113     try {
48114       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);
48115     } catch (std::out_of_range& e) {
48116       {
48117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48118       };
48119     } catch (std::exception& e) {
48120       {
48121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48122       };
48123     } catch (...) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48126       };
48127     }
48128   }
48129   jresult = result;
48130   return jresult;
48131 }
48132
48133
48134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48135   unsigned long jresult ;
48136   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48137   std::size_t result;
48138
48139   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48140   {
48141     try {
48142       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);
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (...) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48154       };
48155     }
48156   }
48157   jresult = (unsigned long)result;
48158   return jresult;
48159 }
48160
48161
48162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48163   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48164   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48165
48166   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48167   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48168   {
48169     try {
48170       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48171     } catch (std::out_of_range& e) {
48172       {
48173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (std::exception& e) {
48176       {
48177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48178       };
48179     } catch (...) {
48180       {
48181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48182       };
48183     }
48184   }
48185 }
48186
48187
48188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48189   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48190   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48191
48192   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48193   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48194   {
48195     try {
48196       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48197     } catch (std::out_of_range& e) {
48198       {
48199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48200       };
48201     } catch (std::exception& e) {
48202       {
48203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48204       };
48205     } catch (...) {
48206       {
48207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48208       };
48209     }
48210   }
48211 }
48212
48213
48214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48215   unsigned int jresult ;
48216   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48217   Dali::Actor arg2 ;
48218   Dali::TouchData *arg3 = 0 ;
48219   Dali::Actor *argp2 ;
48220   bool result;
48221
48222   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48223   argp2 = (Dali::Actor *)jarg2;
48224   if (!argp2) {
48225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48226     return 0;
48227   }
48228   arg2 = *argp2;
48229   arg3 = (Dali::TouchData *)jarg3;
48230   if (!arg3) {
48231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48232     return 0;
48233   }
48234   {
48235     try {
48236       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48237     } catch (std::out_of_range& e) {
48238       {
48239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48240       };
48241     } catch (std::exception& e) {
48242       {
48243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48244       };
48245     } catch (...) {
48246       {
48247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48248       };
48249     }
48250   }
48251   jresult = result;
48252   return jresult;
48253 }
48254
48255
48256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48257   void * jresult ;
48258   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48259
48260   {
48261     try {
48262       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48263     } catch (std::out_of_range& e) {
48264       {
48265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48266       };
48267     } catch (std::exception& e) {
48268       {
48269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48270       };
48271     } catch (...) {
48272       {
48273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48274       };
48275     }
48276   }
48277   jresult = (void *)result;
48278   return jresult;
48279 }
48280
48281
48282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48283   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48284
48285   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48286   {
48287     try {
48288       delete arg1;
48289     } catch (std::out_of_range& e) {
48290       {
48291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48292       };
48293     } catch (std::exception& e) {
48294       {
48295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48296       };
48297     } catch (...) {
48298       {
48299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48300       };
48301     }
48302   }
48303 }
48304
48305
48306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48307   unsigned int jresult ;
48308   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48309   bool result;
48310
48311   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48312   {
48313     try {
48314       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);
48315     } catch (std::out_of_range& e) {
48316       {
48317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48318       };
48319     } catch (std::exception& e) {
48320       {
48321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48326       };
48327     }
48328   }
48329   jresult = result;
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48335   unsigned long jresult ;
48336   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48337   std::size_t result;
48338
48339   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48340   {
48341     try {
48342       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);
48343     } catch (std::out_of_range& e) {
48344       {
48345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48346       };
48347     } catch (std::exception& e) {
48348       {
48349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48350       };
48351     } catch (...) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48354       };
48355     }
48356   }
48357   jresult = (unsigned long)result;
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48363   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48364   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48365
48366   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48367   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48368   {
48369     try {
48370       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48371     } catch (std::out_of_range& e) {
48372       {
48373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48374       };
48375     } catch (std::exception& e) {
48376       {
48377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48378       };
48379     } catch (...) {
48380       {
48381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48382       };
48383     }
48384   }
48385 }
48386
48387
48388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48389   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48390   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48391
48392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48393   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48394   {
48395     try {
48396       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48397     } catch (std::out_of_range& e) {
48398       {
48399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48400       };
48401     } catch (std::exception& e) {
48402       {
48403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48404       };
48405     } catch (...) {
48406       {
48407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48408       };
48409     }
48410   }
48411 }
48412
48413
48414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48415   unsigned int jresult ;
48416   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48417   Dali::Actor arg2 ;
48418   Dali::HoverEvent *arg3 = 0 ;
48419   Dali::Actor *argp2 ;
48420   bool result;
48421
48422   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48423   argp2 = (Dali::Actor *)jarg2;
48424   if (!argp2) {
48425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48426     return 0;
48427   }
48428   arg2 = *argp2;
48429   arg3 = (Dali::HoverEvent *)jarg3;
48430   if (!arg3) {
48431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48432     return 0;
48433   }
48434   {
48435     try {
48436       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48437     } catch (std::out_of_range& e) {
48438       {
48439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48440       };
48441     } catch (std::exception& e) {
48442       {
48443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48444       };
48445     } catch (...) {
48446       {
48447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48448       };
48449     }
48450   }
48451   jresult = result;
48452   return jresult;
48453 }
48454
48455
48456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48457   void * jresult ;
48458   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48459
48460   {
48461     try {
48462       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48463     } catch (std::out_of_range& e) {
48464       {
48465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48466       };
48467     } catch (std::exception& e) {
48468       {
48469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48470       };
48471     } catch (...) {
48472       {
48473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48474       };
48475     }
48476   }
48477   jresult = (void *)result;
48478   return jresult;
48479 }
48480
48481
48482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48483   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48484
48485   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48486   {
48487     try {
48488       delete arg1;
48489     } catch (std::out_of_range& e) {
48490       {
48491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48492       };
48493     } catch (std::exception& e) {
48494       {
48495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48496       };
48497     } catch (...) {
48498       {
48499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48500       };
48501     }
48502   }
48503 }
48504
48505
48506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48507   unsigned int jresult ;
48508   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48509   bool result;
48510
48511   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48512   {
48513     try {
48514       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);
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (...) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48526       };
48527     }
48528   }
48529   jresult = result;
48530   return jresult;
48531 }
48532
48533
48534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48535   unsigned long jresult ;
48536   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48537   std::size_t result;
48538
48539   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48540   {
48541     try {
48542       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);
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48550       };
48551     } catch (...) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48554       };
48555     }
48556   }
48557   jresult = (unsigned long)result;
48558   return jresult;
48559 }
48560
48561
48562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48563   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48564   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48565
48566   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48567   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48568   {
48569     try {
48570       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48571     } catch (std::out_of_range& e) {
48572       {
48573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48574       };
48575     } catch (std::exception& e) {
48576       {
48577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48578       };
48579     } catch (...) {
48580       {
48581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48582       };
48583     }
48584   }
48585 }
48586
48587
48588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48589   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48590   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48591
48592   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48593   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48594   {
48595     try {
48596       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48597     } catch (std::out_of_range& e) {
48598       {
48599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48600       };
48601     } catch (std::exception& e) {
48602       {
48603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48604       };
48605     } catch (...) {
48606       {
48607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48608       };
48609     }
48610   }
48611 }
48612
48613
48614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48615   unsigned int jresult ;
48616   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48617   Dali::Actor arg2 ;
48618   Dali::WheelEvent *arg3 = 0 ;
48619   Dali::Actor *argp2 ;
48620   bool result;
48621
48622   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48623   argp2 = (Dali::Actor *)jarg2;
48624   if (!argp2) {
48625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48626     return 0;
48627   }
48628   arg2 = *argp2;
48629   arg3 = (Dali::WheelEvent *)jarg3;
48630   if (!arg3) {
48631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48632     return 0;
48633   }
48634   {
48635     try {
48636       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48637     } catch (std::out_of_range& e) {
48638       {
48639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48640       };
48641     } catch (std::exception& e) {
48642       {
48643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48644       };
48645     } catch (...) {
48646       {
48647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48648       };
48649     }
48650   }
48651   jresult = result;
48652   return jresult;
48653 }
48654
48655
48656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48657   void * jresult ;
48658   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48659
48660   {
48661     try {
48662       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48663     } catch (std::out_of_range& e) {
48664       {
48665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48666       };
48667     } catch (std::exception& e) {
48668       {
48669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48670       };
48671     } catch (...) {
48672       {
48673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48674       };
48675     }
48676   }
48677   jresult = (void *)result;
48678   return jresult;
48679 }
48680
48681
48682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48683   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48684
48685   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48686   {
48687     try {
48688       delete arg1;
48689     } catch (std::out_of_range& e) {
48690       {
48691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48692       };
48693     } catch (std::exception& e) {
48694       {
48695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48696       };
48697     } catch (...) {
48698       {
48699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48700       };
48701     }
48702   }
48703 }
48704
48705
48706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48707   unsigned int jresult ;
48708   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48709   bool result;
48710
48711   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48712   {
48713     try {
48714       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48715     } catch (std::out_of_range& e) {
48716       {
48717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48718       };
48719     } catch (std::exception& e) {
48720       {
48721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48722       };
48723     } catch (...) {
48724       {
48725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48726       };
48727     }
48728   }
48729   jresult = result;
48730   return jresult;
48731 }
48732
48733
48734 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48735   unsigned long jresult ;
48736   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48737   std::size_t result;
48738
48739   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48740   {
48741     try {
48742       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48743     } catch (std::out_of_range& e) {
48744       {
48745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48746       };
48747     } catch (std::exception& e) {
48748       {
48749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48750       };
48751     } catch (...) {
48752       {
48753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48754       };
48755     }
48756   }
48757   jresult = (unsigned long)result;
48758   return jresult;
48759 }
48760
48761
48762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48763   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48764   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48765
48766   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48767   arg2 = (void (*)(Dali::Actor))jarg2;
48768   {
48769     try {
48770       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48778       };
48779     } catch (...) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48782       };
48783     }
48784   }
48785 }
48786
48787
48788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48789   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48790   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48791
48792   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48793   arg2 = (void (*)(Dali::Actor))jarg2;
48794   {
48795     try {
48796       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48797     } catch (std::out_of_range& e) {
48798       {
48799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48800       };
48801     } catch (std::exception& e) {
48802       {
48803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48804       };
48805     } catch (...) {
48806       {
48807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48808       };
48809     }
48810   }
48811 }
48812
48813
48814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48815   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48816   Dali::Actor arg2 ;
48817   Dali::Actor *argp2 ;
48818
48819   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48820   argp2 = (Dali::Actor *)jarg2;
48821   if (!argp2) {
48822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48823     return ;
48824   }
48825   arg2 = *argp2;
48826   {
48827     try {
48828       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48829     } catch (std::out_of_range& e) {
48830       {
48831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48832       };
48833     } catch (std::exception& e) {
48834       {
48835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (...) {
48838       {
48839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48840       };
48841     }
48842   }
48843 }
48844
48845
48846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48847   void * jresult ;
48848   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48849
48850   {
48851     try {
48852       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48853     } catch (std::out_of_range& e) {
48854       {
48855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48856       };
48857     } catch (std::exception& e) {
48858       {
48859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48860       };
48861     } catch (...) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48864       };
48865     }
48866   }
48867   jresult = (void *)result;
48868   return jresult;
48869 }
48870
48871
48872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48873   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48874
48875   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48876   {
48877     try {
48878       delete arg1;
48879     } catch (std::out_of_range& e) {
48880       {
48881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (std::exception& e) {
48884       {
48885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48886       };
48887     } catch (...) {
48888       {
48889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48890       };
48891     }
48892   }
48893 }
48894
48895
48896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48897   unsigned int jresult ;
48898   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48899   bool result;
48900
48901   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48902   {
48903     try {
48904       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48905     } catch (std::out_of_range& e) {
48906       {
48907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48908       };
48909     } catch (std::exception& e) {
48910       {
48911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48912       };
48913     } catch (...) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48916       };
48917     }
48918   }
48919   jresult = result;
48920   return jresult;
48921 }
48922
48923
48924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48925   unsigned long jresult ;
48926   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48927   std::size_t result;
48928
48929   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48930   {
48931     try {
48932       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48933     } catch (std::out_of_range& e) {
48934       {
48935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48936       };
48937     } catch (std::exception& e) {
48938       {
48939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48940       };
48941     } catch (...) {
48942       {
48943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48944       };
48945     }
48946   }
48947   jresult = (unsigned long)result;
48948   return jresult;
48949 }
48950
48951
48952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48953   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48954   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48955
48956   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48957   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48958   {
48959     try {
48960       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48961     } catch (std::out_of_range& e) {
48962       {
48963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48964       };
48965     } catch (std::exception& e) {
48966       {
48967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48968       };
48969     } catch (...) {
48970       {
48971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48972       };
48973     }
48974   }
48975 }
48976
48977
48978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48979   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48980   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48981
48982   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48983   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48984   {
48985     try {
48986       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48987     } catch (std::out_of_range& e) {
48988       {
48989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48990       };
48991     } catch (std::exception& e) {
48992       {
48993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48994       };
48995     } catch (...) {
48996       {
48997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48998       };
48999     }
49000   }
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
49005   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49006   Dali::KeyEvent *arg2 = 0 ;
49007
49008   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49009   arg2 = (Dali::KeyEvent *)jarg2;
49010   if (!arg2) {
49011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
49012     return ;
49013   }
49014   {
49015     try {
49016       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
49017     } catch (std::out_of_range& e) {
49018       {
49019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49020       };
49021     } catch (std::exception& e) {
49022       {
49023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49024       };
49025     } catch (...) {
49026       {
49027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49028       };
49029     }
49030   }
49031 }
49032
49033
49034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
49035   void * jresult ;
49036   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
49037
49038   {
49039     try {
49040       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
49041     } catch (std::out_of_range& e) {
49042       {
49043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49044       };
49045     } catch (std::exception& e) {
49046       {
49047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49048       };
49049     } catch (...) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49052       };
49053     }
49054   }
49055   jresult = (void *)result;
49056   return jresult;
49057 }
49058
49059
49060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49061   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49062
49063   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49064   {
49065     try {
49066       delete arg1;
49067     } catch (std::out_of_range& e) {
49068       {
49069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49070       };
49071     } catch (std::exception& e) {
49072       {
49073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49074       };
49075     } catch (...) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49078       };
49079     }
49080   }
49081 }
49082
49083
49084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49085   unsigned int jresult ;
49086   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49087   bool result;
49088
49089   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49090   {
49091     try {
49092       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49093     } catch (std::out_of_range& e) {
49094       {
49095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49096       };
49097     } catch (std::exception& e) {
49098       {
49099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49100       };
49101     } catch (...) {
49102       {
49103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49104       };
49105     }
49106   }
49107   jresult = result;
49108   return jresult;
49109 }
49110
49111
49112 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49113   unsigned long jresult ;
49114   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49115   std::size_t result;
49116
49117   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49118   {
49119     try {
49120       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49121     } catch (std::out_of_range& e) {
49122       {
49123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49124       };
49125     } catch (std::exception& e) {
49126       {
49127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49128       };
49129     } catch (...) {
49130       {
49131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49132       };
49133     }
49134   }
49135   jresult = (unsigned long)result;
49136   return jresult;
49137 }
49138
49139
49140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49141   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49142   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49143
49144   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49145   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49146   {
49147     try {
49148       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49156       };
49157     } catch (...) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49160       };
49161     }
49162   }
49163 }
49164
49165
49166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49167   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49168   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49169
49170   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49171   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49172   {
49173     try {
49174       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49175     } catch (std::out_of_range& e) {
49176       {
49177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49178       };
49179     } catch (std::exception& e) {
49180       {
49181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49182       };
49183     } catch (...) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49186       };
49187     }
49188   }
49189 }
49190
49191
49192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49193   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49194   Dali::TouchData *arg2 = 0 ;
49195
49196   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49197   arg2 = (Dali::TouchData *)jarg2;
49198   if (!arg2) {
49199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49200     return ;
49201   }
49202   {
49203     try {
49204       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49205     } catch (std::out_of_range& e) {
49206       {
49207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49208       };
49209     } catch (std::exception& e) {
49210       {
49211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (...) {
49214       {
49215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49216       };
49217     }
49218   }
49219 }
49220
49221
49222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49223   void * jresult ;
49224   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49225
49226   {
49227     try {
49228       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49229     } catch (std::out_of_range& e) {
49230       {
49231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49232       };
49233     } catch (std::exception& e) {
49234       {
49235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49236       };
49237     } catch (...) {
49238       {
49239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49240       };
49241     }
49242   }
49243   jresult = (void *)result;
49244   return jresult;
49245 }
49246
49247
49248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49249   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49250
49251   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49252   {
49253     try {
49254       delete arg1;
49255     } catch (std::out_of_range& e) {
49256       {
49257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49258       };
49259     } catch (std::exception& e) {
49260       {
49261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49262       };
49263     } catch (...) {
49264       {
49265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49266       };
49267     }
49268   }
49269 }
49270
49271
49272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49273   unsigned int jresult ;
49274   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49275   bool result;
49276
49277   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49278   {
49279     try {
49280       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49281     } catch (std::out_of_range& e) {
49282       {
49283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49284       };
49285     } catch (std::exception& e) {
49286       {
49287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49288       };
49289     } catch (...) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49292       };
49293     }
49294   }
49295   jresult = result;
49296   return jresult;
49297 }
49298
49299
49300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49301   unsigned long jresult ;
49302   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49303   std::size_t result;
49304
49305   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49306   {
49307     try {
49308       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49309     } catch (std::out_of_range& e) {
49310       {
49311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49312       };
49313     } catch (std::exception& e) {
49314       {
49315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49316       };
49317     } catch (...) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49320       };
49321     }
49322   }
49323   jresult = (unsigned long)result;
49324   return jresult;
49325 }
49326
49327
49328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49329   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49330   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49331
49332   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49333   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49334   {
49335     try {
49336       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49344       };
49345     } catch (...) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49348       };
49349     }
49350   }
49351 }
49352
49353
49354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49355   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49356   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49357
49358   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49359   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49360   {
49361     try {
49362       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49363     } catch (std::out_of_range& e) {
49364       {
49365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49366       };
49367     } catch (std::exception& e) {
49368       {
49369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49370       };
49371     } catch (...) {
49372       {
49373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49374       };
49375     }
49376   }
49377 }
49378
49379
49380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49381   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49382   Dali::WheelEvent *arg2 = 0 ;
49383
49384   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49385   arg2 = (Dali::WheelEvent *)jarg2;
49386   if (!arg2) {
49387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49388     return ;
49389   }
49390   {
49391     try {
49392       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49393     } catch (std::out_of_range& e) {
49394       {
49395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (std::exception& e) {
49398       {
49399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (...) {
49402       {
49403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49404       };
49405     }
49406   }
49407 }
49408
49409
49410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49411   void * jresult ;
49412   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49413
49414   {
49415     try {
49416       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49417     } catch (std::out_of_range& e) {
49418       {
49419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49420       };
49421     } catch (std::exception& e) {
49422       {
49423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49424       };
49425     } catch (...) {
49426       {
49427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49428       };
49429     }
49430   }
49431   jresult = (void *)result;
49432   return jresult;
49433 }
49434
49435
49436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49437   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49438
49439   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49440   {
49441     try {
49442       delete arg1;
49443     } catch (std::out_of_range& e) {
49444       {
49445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49446       };
49447     } catch (std::exception& e) {
49448       {
49449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49450       };
49451     } catch (...) {
49452       {
49453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49454       };
49455     }
49456   }
49457 }
49458
49459
49460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49461   void * jresult ;
49462   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49463
49464   {
49465     try {
49466       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49467     } catch (std::out_of_range& e) {
49468       {
49469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49470       };
49471     } catch (std::exception& e) {
49472       {
49473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49474       };
49475     } catch (...) {
49476       {
49477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49478       };
49479     }
49480   }
49481   jresult = (void *)result;
49482   return jresult;
49483 }
49484
49485
49486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49487   void * jresult ;
49488   Dali::Radian arg1 ;
49489   Dali::Radian arg2 ;
49490   Dali::Radian *argp1 ;
49491   Dali::Radian *argp2 ;
49492   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49493
49494   argp1 = (Dali::Radian *)jarg1;
49495   if (!argp1) {
49496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49497     return 0;
49498   }
49499   arg1 = *argp1;
49500   argp2 = (Dali::Radian *)jarg2;
49501   if (!argp2) {
49502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49503     return 0;
49504   }
49505   arg2 = *argp2;
49506   {
49507     try {
49508       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49509     } catch (std::out_of_range& e) {
49510       {
49511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49512       };
49513     } catch (std::exception& e) {
49514       {
49515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49516       };
49517     } catch (...) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49520       };
49521     }
49522   }
49523   jresult = (void *)result;
49524   return jresult;
49525 }
49526
49527
49528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49529   void * jresult ;
49530   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49531   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49532
49533   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49534   if (!arg1) {
49535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49536     return 0;
49537   }
49538   {
49539     try {
49540       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49541     } catch (std::out_of_range& e) {
49542       {
49543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49544       };
49545     } catch (std::exception& e) {
49546       {
49547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49548       };
49549     } catch (...) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49552       };
49553     }
49554   }
49555   jresult = (void *)result;
49556   return jresult;
49557 }
49558
49559
49560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49561   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49562   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49563
49564   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49565   arg2 = (Dali::Radian *)jarg2;
49566   if (arg1) (arg1)->first = *arg2;
49567 }
49568
49569
49570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49571   void * jresult ;
49572   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49573   Dali::Radian *result = 0 ;
49574
49575   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49576   result = (Dali::Radian *)& ((arg1)->first);
49577   jresult = (void *)result;
49578   return jresult;
49579 }
49580
49581
49582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49583   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49584   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49585
49586   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49587   arg2 = (Dali::Radian *)jarg2;
49588   if (arg1) (arg1)->second = *arg2;
49589 }
49590
49591
49592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49593   void * jresult ;
49594   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49595   Dali::Radian *result = 0 ;
49596
49597   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49598   result = (Dali::Radian *)& ((arg1)->second);
49599   jresult = (void *)result;
49600   return jresult;
49601 }
49602
49603
49604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49605   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49606
49607   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49608   {
49609     try {
49610       delete arg1;
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49618       };
49619     } catch (...) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49622       };
49623     }
49624   }
49625 }
49626
49627
49628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49629   unsigned int jresult ;
49630   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49631   bool result;
49632
49633   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49634   {
49635     try {
49636       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);
49637     } catch (std::out_of_range& e) {
49638       {
49639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49640       };
49641     } catch (std::exception& e) {
49642       {
49643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49644       };
49645     } catch (...) {
49646       {
49647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49648       };
49649     }
49650   }
49651   jresult = result;
49652   return jresult;
49653 }
49654
49655
49656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49657   unsigned long jresult ;
49658   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49659   std::size_t result;
49660
49661   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49662   {
49663     try {
49664       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);
49665     } catch (std::out_of_range& e) {
49666       {
49667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49668       };
49669     } catch (std::exception& e) {
49670       {
49671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49672       };
49673     } catch (...) {
49674       {
49675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49676       };
49677     }
49678   }
49679   jresult = (unsigned long)result;
49680   return jresult;
49681 }
49682
49683
49684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49685   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49686   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49687
49688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49689   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49690   {
49691     try {
49692       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49693     } catch (std::out_of_range& e) {
49694       {
49695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49696       };
49697     } catch (std::exception& e) {
49698       {
49699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49700       };
49701     } catch (...) {
49702       {
49703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49704       };
49705     }
49706   }
49707 }
49708
49709
49710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49711   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49712   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49713
49714   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49715   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49716   {
49717     try {
49718       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49719     } catch (std::out_of_range& e) {
49720       {
49721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49722       };
49723     } catch (std::exception& e) {
49724       {
49725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49726       };
49727     } catch (...) {
49728       {
49729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49730       };
49731     }
49732   }
49733 }
49734
49735
49736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49737   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49738   Dali::Actor arg2 ;
49739   Dali::PanGesture *arg3 = 0 ;
49740   Dali::Actor *argp2 ;
49741
49742   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49743   argp2 = (Dali::Actor *)jarg2;
49744   if (!argp2) {
49745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49746     return ;
49747   }
49748   arg2 = *argp2;
49749   arg3 = (Dali::PanGesture *)jarg3;
49750   if (!arg3) {
49751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49752     return ;
49753   }
49754   {
49755     try {
49756       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49757     } catch (std::out_of_range& e) {
49758       {
49759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49760       };
49761     } catch (std::exception& e) {
49762       {
49763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (...) {
49766       {
49767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49768       };
49769     }
49770   }
49771 }
49772
49773
49774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49775   void * jresult ;
49776   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49777
49778   {
49779     try {
49780       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49781     } catch (std::out_of_range& e) {
49782       {
49783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49784       };
49785     } catch (std::exception& e) {
49786       {
49787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49788       };
49789     } catch (...) {
49790       {
49791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49792       };
49793     }
49794   }
49795   jresult = (void *)result;
49796   return jresult;
49797 }
49798
49799
49800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49801   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49802
49803   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49804   {
49805     try {
49806       delete arg1;
49807     } catch (std::out_of_range& e) {
49808       {
49809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49810       };
49811     } catch (std::exception& e) {
49812       {
49813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49814       };
49815     } catch (...) {
49816       {
49817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49818       };
49819     }
49820   }
49821 }
49822
49823
49824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49825   unsigned int jresult ;
49826   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49827   bool result;
49828
49829   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49830   {
49831     try {
49832       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);
49833     } catch (std::out_of_range& e) {
49834       {
49835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49836       };
49837     } catch (std::exception& e) {
49838       {
49839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49840       };
49841     } catch (...) {
49842       {
49843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49844       };
49845     }
49846   }
49847   jresult = result;
49848   return jresult;
49849 }
49850
49851
49852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49853   unsigned long jresult ;
49854   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49855   std::size_t result;
49856
49857   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49858   {
49859     try {
49860       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);
49861     } catch (std::out_of_range& e) {
49862       {
49863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49864       };
49865     } catch (std::exception& e) {
49866       {
49867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49868       };
49869     } catch (...) {
49870       {
49871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49872       };
49873     }
49874   }
49875   jresult = (unsigned long)result;
49876   return jresult;
49877 }
49878
49879
49880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49881   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49882   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49883
49884   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49885   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49886   {
49887     try {
49888       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49889     } catch (std::out_of_range& e) {
49890       {
49891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49892       };
49893     } catch (std::exception& e) {
49894       {
49895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49896       };
49897     } catch (...) {
49898       {
49899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49900       };
49901     }
49902   }
49903 }
49904
49905
49906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49907   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49908   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49909
49910   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49911   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49912   {
49913     try {
49914       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49915     } catch (std::out_of_range& e) {
49916       {
49917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (std::exception& e) {
49920       {
49921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49922       };
49923     } catch (...) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49926       };
49927     }
49928   }
49929 }
49930
49931
49932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49933   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49934   Dali::Actor arg2 ;
49935   Dali::PinchGesture *arg3 = 0 ;
49936   Dali::Actor *argp2 ;
49937
49938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49939   argp2 = (Dali::Actor *)jarg2;
49940   if (!argp2) {
49941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49942     return ;
49943   }
49944   arg2 = *argp2;
49945   arg3 = (Dali::PinchGesture *)jarg3;
49946   if (!arg3) {
49947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49948     return ;
49949   }
49950   {
49951     try {
49952       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49953     } catch (std::out_of_range& e) {
49954       {
49955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49956       };
49957     } catch (std::exception& e) {
49958       {
49959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (...) {
49962       {
49963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49964       };
49965     }
49966   }
49967 }
49968
49969
49970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49971   void * jresult ;
49972   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49973
49974   {
49975     try {
49976       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49977     } catch (std::out_of_range& e) {
49978       {
49979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49980       };
49981     } catch (std::exception& e) {
49982       {
49983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49984       };
49985     } catch (...) {
49986       {
49987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49988       };
49989     }
49990   }
49991   jresult = (void *)result;
49992   return jresult;
49993 }
49994
49995
49996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49997   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49998
49999   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
50000   {
50001     try {
50002       delete arg1;
50003     } catch (std::out_of_range& e) {
50004       {
50005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50006       };
50007     } catch (std::exception& e) {
50008       {
50009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50010       };
50011     } catch (...) {
50012       {
50013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50014       };
50015     }
50016   }
50017 }
50018
50019
50020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
50021   unsigned int jresult ;
50022   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50023   bool result;
50024
50025   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50026   {
50027     try {
50028       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);
50029     } catch (std::out_of_range& e) {
50030       {
50031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50032       };
50033     } catch (std::exception& e) {
50034       {
50035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50036       };
50037     } catch (...) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50040       };
50041     }
50042   }
50043   jresult = result;
50044   return jresult;
50045 }
50046
50047
50048 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50049   unsigned long jresult ;
50050   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50051   std::size_t result;
50052
50053   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50054   {
50055     try {
50056       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);
50057     } catch (std::out_of_range& e) {
50058       {
50059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50060       };
50061     } catch (std::exception& e) {
50062       {
50063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50064       };
50065     } catch (...) {
50066       {
50067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50068       };
50069     }
50070   }
50071   jresult = (unsigned long)result;
50072   return jresult;
50073 }
50074
50075
50076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50077   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50078   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50079
50080   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50081   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50082   {
50083     try {
50084       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50085     } catch (std::out_of_range& e) {
50086       {
50087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50088       };
50089     } catch (std::exception& e) {
50090       {
50091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50092       };
50093     } catch (...) {
50094       {
50095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50096       };
50097     }
50098   }
50099 }
50100
50101
50102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50103   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50104   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50105
50106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50107   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50108   {
50109     try {
50110       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50111     } catch (std::out_of_range& e) {
50112       {
50113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50114       };
50115     } catch (std::exception& e) {
50116       {
50117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50118       };
50119     } catch (...) {
50120       {
50121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50122       };
50123     }
50124   }
50125 }
50126
50127
50128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50129   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50130   Dali::Actor arg2 ;
50131   Dali::TapGesture *arg3 = 0 ;
50132   Dali::Actor *argp2 ;
50133
50134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50135   argp2 = (Dali::Actor *)jarg2;
50136   if (!argp2) {
50137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50138     return ;
50139   }
50140   arg2 = *argp2;
50141   arg3 = (Dali::TapGesture *)jarg3;
50142   if (!arg3) {
50143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50144     return ;
50145   }
50146   {
50147     try {
50148       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50149     } catch (std::out_of_range& e) {
50150       {
50151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50152       };
50153     } catch (std::exception& e) {
50154       {
50155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50156       };
50157     } catch (...) {
50158       {
50159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50160       };
50161     }
50162   }
50163 }
50164
50165
50166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50167   void * jresult ;
50168   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50169
50170   {
50171     try {
50172       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50173     } catch (std::out_of_range& e) {
50174       {
50175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50176       };
50177     } catch (std::exception& e) {
50178       {
50179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50180       };
50181     } catch (...) {
50182       {
50183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50184       };
50185     }
50186   }
50187   jresult = (void *)result;
50188   return jresult;
50189 }
50190
50191
50192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50193   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50194
50195   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50196   {
50197     try {
50198       delete arg1;
50199     } catch (std::out_of_range& e) {
50200       {
50201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50202       };
50203     } catch (std::exception& e) {
50204       {
50205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50206       };
50207     } catch (...) {
50208       {
50209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50210       };
50211     }
50212   }
50213 }
50214
50215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50216   unsigned int jresult ;
50217   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50218   bool result;
50219
50220   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50221   {
50222     try {
50223       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50224     } catch (std::out_of_range& e) {
50225       {
50226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50227       };
50228     } catch (std::exception& e) {
50229       {
50230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50231       };
50232     } catch (...) {
50233       {
50234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50235       };
50236     }
50237   }
50238   jresult = result;
50239   return jresult;
50240 }
50241
50242
50243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50244   unsigned long jresult ;
50245   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50246   std::size_t result;
50247
50248   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50249   {
50250     try {
50251       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50252     } catch (std::out_of_range& e) {
50253       {
50254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50255       };
50256     } catch (std::exception& e) {
50257       {
50258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50259       };
50260     } catch (...) {
50261       {
50262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50263       };
50264     }
50265   }
50266   jresult = (unsigned long)result;
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50272   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50273   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50274
50275   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50276   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50277   {
50278     try {
50279       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50280     } catch (std::out_of_range& e) {
50281       {
50282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50283       };
50284     } catch (std::exception& e) {
50285       {
50286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50287       };
50288     } catch (...) {
50289       {
50290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50291       };
50292     }
50293   }
50294 }
50295
50296
50297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50298   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50299   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50300
50301   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50302   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50303   {
50304     try {
50305       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50306     } catch (std::out_of_range& e) {
50307       {
50308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50309       };
50310     } catch (std::exception& e) {
50311       {
50312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50313       };
50314     } catch (...) {
50315       {
50316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50317       };
50318     }
50319   }
50320 }
50321
50322
50323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50324   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50325   Dali::ResourceImage arg2 ;
50326   Dali::ResourceImage *argp2 ;
50327
50328   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50329   argp2 = (Dali::ResourceImage *)jarg2;
50330   if (!argp2) {
50331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50332     return ;
50333   }
50334   arg2 = *argp2;
50335   {
50336     try {
50337       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50345       };
50346     } catch (...) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50349       };
50350     }
50351   }
50352 }
50353
50354
50355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50356   void * jresult ;
50357   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50358
50359   {
50360     try {
50361       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50362     } catch (std::out_of_range& e) {
50363       {
50364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50365       };
50366     } catch (std::exception& e) {
50367       {
50368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50369       };
50370     } catch (...) {
50371       {
50372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50373       };
50374     }
50375   }
50376   jresult = (void *)result;
50377   return jresult;
50378 }
50379
50380
50381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50382   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50383
50384   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50385   {
50386     try {
50387       delete arg1;
50388     } catch (std::out_of_range& e) {
50389       {
50390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50391       };
50392     } catch (std::exception& e) {
50393       {
50394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50395       };
50396     } catch (...) {
50397       {
50398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50399       };
50400     }
50401   }
50402 }
50403
50404
50405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50406   unsigned int jresult ;
50407   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50408   bool result;
50409
50410   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50411   {
50412     try {
50413       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);
50414     } catch (std::out_of_range& e) {
50415       {
50416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50417       };
50418     } catch (std::exception& e) {
50419       {
50420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50421       };
50422     } catch (...) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50425       };
50426     }
50427   }
50428   jresult = result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50434   unsigned long jresult ;
50435   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50436   std::size_t result;
50437
50438   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50439   {
50440     try {
50441       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);
50442     } catch (std::out_of_range& e) {
50443       {
50444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50445       };
50446     } catch (std::exception& e) {
50447       {
50448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50449       };
50450     } catch (...) {
50451       {
50452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50453       };
50454     }
50455   }
50456   jresult = (unsigned long)result;
50457   return jresult;
50458 }
50459
50460
50461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50462   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50463   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50464
50465   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50466   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50467   {
50468     try {
50469       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50470     } catch (std::out_of_range& e) {
50471       {
50472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50473       };
50474     } catch (std::exception& e) {
50475       {
50476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50477       };
50478     } catch (...) {
50479       {
50480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50481       };
50482     }
50483   }
50484 }
50485
50486
50487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50488   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50489   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50490
50491   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50492   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50493   {
50494     try {
50495       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50496     } catch (std::out_of_range& e) {
50497       {
50498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50499       };
50500     } catch (std::exception& e) {
50501       {
50502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50507       };
50508     }
50509   }
50510 }
50511
50512
50513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50514   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50515   Dali::Actor arg2 ;
50516   bool arg3 ;
50517   Dali::DevelActor::VisibilityChange::Type arg4 ;
50518   Dali::Actor *argp2 ;
50519
50520   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50521   argp2 = (Dali::Actor *)jarg2;
50522   if (!argp2) {
50523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50524     return ;
50525   }
50526   arg2 = *argp2;
50527   arg3 = jarg3 ? true : false;
50528   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50529   {
50530     try {
50531       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50532     } catch (std::out_of_range& e) {
50533       {
50534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50535       };
50536     } catch (std::exception& e) {
50537       {
50538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50539       };
50540     } catch (...) {
50541       {
50542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50543       };
50544     }
50545   }
50546 }
50547
50548
50549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50550   void * jresult ;
50551   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50552
50553   {
50554     try {
50555       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50556     } catch (std::out_of_range& e) {
50557       {
50558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50559       };
50560     } catch (std::exception& e) {
50561       {
50562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50563       };
50564     } catch (...) {
50565       {
50566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50567       };
50568     }
50569   }
50570   jresult = (void *)result;
50571   return jresult;
50572 }
50573
50574
50575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50576   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50577
50578   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50579   {
50580     try {
50581       delete arg1;
50582     } catch (std::out_of_range& e) {
50583       {
50584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50585       };
50586     } catch (std::exception& e) {
50587       {
50588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50589       };
50590     } catch (...) {
50591       {
50592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50593       };
50594     }
50595   }
50596 }
50597
50598
50599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50600   void * jresult ;
50601   Dali::Timer *result = 0 ;
50602
50603   {
50604     try {
50605       result = (Dali::Timer *)new Dali::Timer();
50606     } catch (std::out_of_range& e) {
50607       {
50608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50609       };
50610     } catch (std::exception& e) {
50611       {
50612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50613       };
50614     } catch (...) {
50615       {
50616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50617       };
50618     }
50619   }
50620   jresult = (void *)result;
50621   return jresult;
50622 }
50623
50624
50625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50626   void * jresult ;
50627   unsigned int arg1 ;
50628   Dali::Timer result;
50629
50630   arg1 = (unsigned int)jarg1;
50631   {
50632     try {
50633       result = Dali::Timer::New(arg1);
50634     } catch (std::out_of_range& e) {
50635       {
50636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50637       };
50638     } catch (std::exception& e) {
50639       {
50640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50641       };
50642     } catch (...) {
50643       {
50644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50645       };
50646     }
50647   }
50648   jresult = new Dali::Timer((const Dali::Timer &)result);
50649   return jresult;
50650 }
50651
50652
50653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50654   void * jresult ;
50655   Dali::Timer *arg1 = 0 ;
50656   Dali::Timer *result = 0 ;
50657
50658   arg1 = (Dali::Timer *)jarg1;
50659   if (!arg1) {
50660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50661     return 0;
50662   }
50663   {
50664     try {
50665       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50666     } catch (std::out_of_range& e) {
50667       {
50668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50669       };
50670     } catch (std::exception& e) {
50671       {
50672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50673       };
50674     } catch (...) {
50675       {
50676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50677       };
50678     }
50679   }
50680   jresult = (void *)result;
50681   return jresult;
50682 }
50683
50684
50685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50686   void * jresult ;
50687   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50688   Dali::Timer *arg2 = 0 ;
50689   Dali::Timer *result = 0 ;
50690
50691   arg1 = (Dali::Timer *)jarg1;
50692   arg2 = (Dali::Timer *)jarg2;
50693   if (!arg2) {
50694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50695     return 0;
50696   }
50697   {
50698     try {
50699       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50700     } catch (std::out_of_range& e) {
50701       {
50702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50703       };
50704     } catch (std::exception& e) {
50705       {
50706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50707       };
50708     } catch (...) {
50709       {
50710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50711       };
50712     }
50713   }
50714   jresult = (void *)result;
50715   return jresult;
50716 }
50717
50718
50719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50720   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50721
50722   arg1 = (Dali::Timer *)jarg1;
50723   {
50724     try {
50725       delete arg1;
50726     } catch (std::out_of_range& e) {
50727       {
50728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50729       };
50730     } catch (std::exception& e) {
50731       {
50732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50733       };
50734     } catch (...) {
50735       {
50736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50737       };
50738     }
50739   }
50740 }
50741
50742
50743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50744   void * jresult ;
50745   Dali::BaseHandle arg1 ;
50746   Dali::BaseHandle *argp1 ;
50747   Dali::Timer result;
50748
50749   argp1 = (Dali::BaseHandle *)jarg1;
50750   if (!argp1) {
50751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50752     return 0;
50753   }
50754   arg1 = *argp1;
50755   {
50756     try {
50757       result = Dali::Timer::DownCast(arg1);
50758     } catch (std::out_of_range& e) {
50759       {
50760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50761       };
50762     } catch (std::exception& e) {
50763       {
50764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50765       };
50766     } catch (...) {
50767       {
50768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50769       };
50770     }
50771   }
50772   jresult = new Dali::Timer((const Dali::Timer &)result);
50773   return jresult;
50774 }
50775
50776
50777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50778   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50779
50780   arg1 = (Dali::Timer *)jarg1;
50781   {
50782     try {
50783       (arg1)->Start();
50784     } catch (std::out_of_range& e) {
50785       {
50786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50787       };
50788     } catch (std::exception& e) {
50789       {
50790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50791       };
50792     } catch (...) {
50793       {
50794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50795       };
50796     }
50797   }
50798 }
50799
50800
50801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50802   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50803
50804   arg1 = (Dali::Timer *)jarg1;
50805   {
50806     try {
50807       (arg1)->Stop();
50808     } catch (std::out_of_range& e) {
50809       {
50810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50811       };
50812     } catch (std::exception& e) {
50813       {
50814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50815       };
50816     } catch (...) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50819       };
50820     }
50821   }
50822 }
50823
50824
50825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50826   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50827   unsigned int arg2 ;
50828
50829   arg1 = (Dali::Timer *)jarg1;
50830   arg2 = (unsigned int)jarg2;
50831   {
50832     try {
50833       (arg1)->SetInterval(arg2);
50834     } catch (std::out_of_range& e) {
50835       {
50836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50837       };
50838     } catch (std::exception& e) {
50839       {
50840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50841       };
50842     } catch (...) {
50843       {
50844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50845       };
50846     }
50847   }
50848 }
50849
50850
50851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50852   unsigned int jresult ;
50853   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50854   unsigned int result;
50855
50856   arg1 = (Dali::Timer *)jarg1;
50857   {
50858     try {
50859       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50860     } catch (std::out_of_range& e) {
50861       {
50862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50863       };
50864     } catch (std::exception& e) {
50865       {
50866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50867       };
50868     } catch (...) {
50869       {
50870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50871       };
50872     }
50873   }
50874   jresult = result;
50875   return jresult;
50876 }
50877
50878
50879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50880   unsigned int jresult ;
50881   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50882   bool result;
50883
50884   arg1 = (Dali::Timer *)jarg1;
50885   {
50886     try {
50887       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50888     } catch (std::out_of_range& e) {
50889       {
50890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (std::exception& e) {
50893       {
50894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50895       };
50896     } catch (...) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50899       };
50900     }
50901   }
50902   jresult = result;
50903   return jresult;
50904 }
50905
50906
50907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50908   void * jresult ;
50909   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50910   Dali::Timer::TimerSignalType *result = 0 ;
50911
50912   arg1 = (Dali::Timer *)jarg1;
50913   {
50914     try {
50915       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50916     } catch (std::out_of_range& e) {
50917       {
50918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50919       };
50920     } catch (std::exception& e) {
50921       {
50922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50923       };
50924     } catch (...) {
50925       {
50926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50927       };
50928     }
50929   }
50930   jresult = (void *)result;
50931   return jresult;
50932 }
50933
50934
50935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50936   void * jresult ;
50937   Dali::DragAndDropDetector *result = 0 ;
50938
50939   {
50940     try {
50941       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50942     } catch (std::out_of_range& e) {
50943       {
50944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50945       };
50946     } catch (std::exception& e) {
50947       {
50948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50949       };
50950     } catch (...) {
50951       {
50952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50953       };
50954     }
50955   }
50956   jresult = (void *)result;
50957   return jresult;
50958 }
50959
50960
50961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50962   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50963
50964   arg1 = (Dali::DragAndDropDetector *)jarg1;
50965   {
50966     try {
50967       delete arg1;
50968     } catch (std::out_of_range& e) {
50969       {
50970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50971       };
50972     } catch (std::exception& e) {
50973       {
50974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50975       };
50976     } catch (...) {
50977       {
50978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50979       };
50980     }
50981   }
50982 }
50983
50984
50985 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50986   char * jresult ;
50987   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50988   std::string *result = 0 ;
50989
50990   arg1 = (Dali::DragAndDropDetector *)jarg1;
50991   {
50992     try {
50993       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50994     } catch (std::out_of_range& e) {
50995       {
50996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50997       };
50998     } catch (std::exception& e) {
50999       {
51000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51001       };
51002     } catch (...) {
51003       {
51004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51005       };
51006     }
51007   }
51008   jresult = SWIG_csharp_string_callback(result->c_str());
51009   return jresult;
51010 }
51011
51012
51013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
51014   void * jresult ;
51015   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51016   Dali::Vector2 result;
51017
51018   arg1 = (Dali::DragAndDropDetector *)jarg1;
51019   {
51020     try {
51021       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
51022     } catch (std::out_of_range& e) {
51023       {
51024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51025       };
51026     } catch (std::exception& e) {
51027       {
51028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51029       };
51030     } catch (...) {
51031       {
51032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51033       };
51034     }
51035   }
51036   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
51037   return jresult;
51038 }
51039
51040
51041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
51042   void * jresult ;
51043   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51044   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51045
51046   arg1 = (Dali::DragAndDropDetector *)jarg1;
51047   {
51048     try {
51049       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51050     } catch (std::out_of_range& e) {
51051       {
51052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51053       };
51054     } catch (std::exception& e) {
51055       {
51056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51057       };
51058     } catch (...) {
51059       {
51060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51061       };
51062     }
51063   }
51064   jresult = (void *)result;
51065   return jresult;
51066 }
51067
51068
51069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51070   void * jresult ;
51071   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51072   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51073
51074   arg1 = (Dali::DragAndDropDetector *)jarg1;
51075   {
51076     try {
51077       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51085       };
51086     } catch (...) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51089       };
51090     }
51091   }
51092   jresult = (void *)result;
51093   return jresult;
51094 }
51095
51096
51097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51098   void * jresult ;
51099   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51100   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51101
51102   arg1 = (Dali::DragAndDropDetector *)jarg1;
51103   {
51104     try {
51105       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
51106     } catch (std::out_of_range& e) {
51107       {
51108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51109       };
51110     } catch (std::exception& e) {
51111       {
51112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51113       };
51114     } catch (...) {
51115       {
51116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51117       };
51118     }
51119   }
51120   jresult = (void *)result;
51121   return jresult;
51122 }
51123
51124
51125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
51126   void * jresult ;
51127   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51128   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51129
51130   arg1 = (Dali::DragAndDropDetector *)jarg1;
51131   {
51132     try {
51133       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51141       };
51142     } catch (...) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51145       };
51146     }
51147   }
51148   jresult = (void *)result;
51149   return jresult;
51150 }
51151
51152
51153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51154   void * jresult ;
51155   Dali::ApplicationExtensions *result = 0 ;
51156
51157   {
51158     try {
51159       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51160     } catch (std::out_of_range& e) {
51161       {
51162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51163       };
51164     } catch (std::exception& e) {
51165       {
51166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51167       };
51168     } catch (...) {
51169       {
51170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51171       };
51172     }
51173   }
51174   jresult = (void *)result;
51175   return jresult;
51176 }
51177
51178
51179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51180   void * jresult ;
51181   Dali::Application *arg1 = (Dali::Application *) 0 ;
51182   Dali::ApplicationExtensions *result = 0 ;
51183
51184   arg1 = (Dali::Application *)jarg1;
51185   {
51186     try {
51187       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51188     } catch (std::out_of_range& e) {
51189       {
51190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51191       };
51192     } catch (std::exception& e) {
51193       {
51194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51195       };
51196     } catch (...) {
51197       {
51198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51199       };
51200     }
51201   }
51202   jresult = (void *)result;
51203   return jresult;
51204 }
51205
51206
51207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51208   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51209
51210   arg1 = (Dali::ApplicationExtensions *)jarg1;
51211   {
51212     try {
51213       delete arg1;
51214     } catch (std::out_of_range& e) {
51215       {
51216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51217       };
51218     } catch (std::exception& e) {
51219       {
51220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51221       };
51222     } catch (...) {
51223       {
51224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51225       };
51226     }
51227   }
51228 }
51229
51230
51231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
51232   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51233
51234   arg1 = (Dali::ApplicationExtensions *)jarg1;
51235   {
51236     try {
51237       (arg1)->Init();
51238     } catch (std::out_of_range& e) {
51239       {
51240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51241       };
51242     } catch (std::exception& e) {
51243       {
51244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51245       };
51246     } catch (...) {
51247       {
51248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51249       };
51250     }
51251   }
51252 }
51253
51254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51255   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51256
51257   arg1 = (Dali::ApplicationExtensions *)jarg1;
51258   {
51259     try {
51260       (arg1)->Start();
51261     } catch (std::out_of_range& e) {
51262       {
51263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51264       };
51265     } catch (std::exception& e) {
51266       {
51267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51268       };
51269     } catch (...) {
51270       {
51271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51272       };
51273     }
51274   }
51275 }
51276
51277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51278   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51279
51280   arg1 = (Dali::ApplicationExtensions *)jarg1;
51281   {
51282     try {
51283       (arg1)->Terminate();
51284     } catch (std::out_of_range& e) {
51285       {
51286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51287       };
51288     } catch (std::exception& e) {
51289       {
51290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51291       };
51292     } catch (...) {
51293       {
51294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51295       };
51296     }
51297   }
51298 }
51299
51300
51301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51302   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51303
51304   arg1 = (Dali::ApplicationExtensions *)jarg1;
51305   {
51306     try {
51307       (arg1)->Pause();
51308     } catch (std::out_of_range& e) {
51309       {
51310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51311       };
51312     } catch (std::exception& e) {
51313       {
51314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51315       };
51316     } catch (...) {
51317       {
51318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51319       };
51320     }
51321   }
51322 }
51323
51324
51325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51326   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51327
51328   arg1 = (Dali::ApplicationExtensions *)jarg1;
51329   {
51330     try {
51331       (arg1)->Resume();
51332     } catch (std::out_of_range& e) {
51333       {
51334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51335       };
51336     } catch (std::exception& e) {
51337       {
51338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51339       };
51340     } catch (...) {
51341       {
51342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51343       };
51344     }
51345   }
51346 }
51347
51348
51349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51350   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51351
51352   arg1 = (Dali::ApplicationExtensions *)jarg1;
51353   {
51354     try {
51355       (arg1)->LanguageChange();
51356     } catch (std::out_of_range& e) {
51357       {
51358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51359       };
51360     } catch (std::exception& e) {
51361       {
51362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51363       };
51364     } catch (...) {
51365       {
51366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51367       };
51368     }
51369   }
51370 }
51371
51372
51373
51374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51375   unsigned int jresult ;
51376   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51377   bool result;
51378
51379   arg1 = (Dali::Signal< bool () > *)jarg1;
51380   {
51381     try {
51382       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51383     } catch (std::out_of_range& e) {
51384       {
51385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51386       };
51387     } catch (std::exception& e) {
51388       {
51389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51390       };
51391     } catch (...) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51394       };
51395     }
51396   }
51397   jresult = result;
51398   return jresult;
51399 }
51400
51401
51402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51403   unsigned long jresult ;
51404   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51405   std::size_t result;
51406
51407   arg1 = (Dali::Signal< bool () > *)jarg1;
51408   {
51409     try {
51410       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51411     } catch (std::out_of_range& e) {
51412       {
51413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51414       };
51415     } catch (std::exception& e) {
51416       {
51417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51418       };
51419     } catch (...) {
51420       {
51421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51422       };
51423     }
51424   }
51425   jresult = (unsigned long)result;
51426   return jresult;
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51431   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51432   bool (*arg2)() = (bool (*)()) 0 ;
51433
51434   arg1 = (Dali::Signal< bool () > *)jarg1;
51435   arg2 = (bool (*)())jarg2;
51436   {
51437     try {
51438       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51439     } catch (std::out_of_range& e) {
51440       {
51441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (std::exception& e) {
51444       {
51445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (...) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51450       };
51451     }
51452   }
51453 }
51454
51455
51456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51457   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51458   bool (*arg2)() = (bool (*)()) 0 ;
51459
51460   arg1 = (Dali::Signal< bool () > *)jarg1;
51461   arg2 = (bool (*)())jarg2;
51462   {
51463     try {
51464       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51465     } catch (std::out_of_range& e) {
51466       {
51467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51468       };
51469     } catch (std::exception& e) {
51470       {
51471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51472       };
51473     } catch (...) {
51474       {
51475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51476       };
51477     }
51478   }
51479 }
51480
51481
51482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51483   unsigned int jresult ;
51484   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51485   bool result;
51486
51487   arg1 = (Dali::Signal< bool () > *)jarg1;
51488   {
51489     try {
51490       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51491     } catch (std::out_of_range& e) {
51492       {
51493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51494       };
51495     } catch (std::exception& e) {
51496       {
51497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51498       };
51499     } catch (...) {
51500       {
51501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51502       };
51503     }
51504   }
51505   jresult = result;
51506   return jresult;
51507 }
51508
51509
51510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51511   void * jresult ;
51512   Dali::Signal< bool () > *result = 0 ;
51513
51514   {
51515     try {
51516       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51517     } catch (std::out_of_range& e) {
51518       {
51519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (std::exception& e) {
51522       {
51523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (...) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51528       };
51529     }
51530   }
51531   jresult = (void *)result;
51532   return jresult;
51533 }
51534
51535
51536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51537   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51538
51539   arg1 = (Dali::Signal< bool () > *)jarg1;
51540   {
51541     try {
51542       delete arg1;
51543     } catch (std::out_of_range& e) {
51544       {
51545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51546       };
51547     } catch (std::exception& e) {
51548       {
51549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (...) {
51552       {
51553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51554       };
51555     }
51556   }
51557 }
51558
51559
51560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51561   int jresult ;
51562   int result;
51563
51564   {
51565     try {
51566       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51567     } catch (std::out_of_range& e) {
51568       {
51569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51570       };
51571     } catch (std::exception& e) {
51572       {
51573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (...) {
51576       {
51577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51578       };
51579     }
51580   }
51581   jresult = (int)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51587   int jresult ;
51588   int result;
51589
51590   {
51591     try {
51592       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51593     } catch (std::out_of_range& e) {
51594       {
51595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51596       };
51597     } catch (std::exception& e) {
51598       {
51599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51600       };
51601     } catch (...) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51604       };
51605     }
51606   }
51607   jresult = (int)result;
51608   return jresult;
51609 }
51610
51611
51612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51613   int jresult ;
51614   int result;
51615
51616   {
51617     try {
51618       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51619     } catch (std::out_of_range& e) {
51620       {
51621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51622       };
51623     } catch (std::exception& e) {
51624       {
51625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51626       };
51627     } catch (...) {
51628       {
51629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51630       };
51631     }
51632   }
51633   jresult = (int)result;
51634   return jresult;
51635 }
51636
51637
51638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51639   int jresult ;
51640   int result;
51641
51642   {
51643     try {
51644       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51645     } catch (std::out_of_range& e) {
51646       {
51647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (std::exception& e) {
51650       {
51651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659   jresult = (int)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51665   int jresult ;
51666   int result;
51667
51668   {
51669     try {
51670       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51671     } catch (std::out_of_range& e) {
51672       {
51673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51674       };
51675     } catch (std::exception& e) {
51676       {
51677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51678       };
51679     } catch (...) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51682       };
51683     }
51684   }
51685   jresult = (int)result;
51686   return jresult;
51687 }
51688
51689
51690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51691   int jresult ;
51692   int result;
51693
51694   {
51695     try {
51696       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51697     } catch (std::out_of_range& e) {
51698       {
51699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51700       };
51701     } catch (std::exception& e) {
51702       {
51703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51704       };
51705     } catch (...) {
51706       {
51707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51708       };
51709     }
51710   }
51711   jresult = (int)result;
51712   return jresult;
51713 }
51714
51715
51716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51717   int jresult ;
51718   int result;
51719
51720   {
51721     try {
51722       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51723     } catch (std::out_of_range& e) {
51724       {
51725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51726       };
51727     } catch (std::exception& e) {
51728       {
51729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51730       };
51731     } catch (...) {
51732       {
51733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51734       };
51735     }
51736   }
51737   jresult = (int)result;
51738   return jresult;
51739 }
51740
51741
51742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51743   int jresult ;
51744   int result;
51745
51746   {
51747     try {
51748       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51749     } catch (std::out_of_range& e) {
51750       {
51751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51752       };
51753     } catch (std::exception& e) {
51754       {
51755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51756       };
51757     } catch (...) {
51758       {
51759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51760       };
51761     }
51762   }
51763   jresult = (int)result;
51764   return jresult;
51765 }
51766
51767
51768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51769   int jresult ;
51770   int result;
51771
51772   {
51773     try {
51774       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51775     } catch (std::out_of_range& e) {
51776       {
51777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51778       };
51779     } catch (std::exception& e) {
51780       {
51781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51782       };
51783     } catch (...) {
51784       {
51785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51786       };
51787     }
51788   }
51789   jresult = (int)result;
51790   return jresult;
51791 }
51792
51793
51794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51795   int jresult ;
51796   int result;
51797
51798   {
51799     try {
51800       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51801     } catch (std::out_of_range& e) {
51802       {
51803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51804       };
51805     } catch (std::exception& e) {
51806       {
51807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51808       };
51809     } catch (...) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51812       };
51813     }
51814   }
51815   jresult = (int)result;
51816   return jresult;
51817 }
51818
51819
51820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51821   int jresult ;
51822   int result;
51823
51824   {
51825     try {
51826       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51827     } catch (std::out_of_range& e) {
51828       {
51829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51830       };
51831     } catch (std::exception& e) {
51832       {
51833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51834       };
51835     } catch (...) {
51836       {
51837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51838       };
51839     }
51840   }
51841   jresult = (int)result;
51842   return jresult;
51843 }
51844
51845
51846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51847   int jresult ;
51848   int result;
51849
51850   {
51851     try {
51852       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51853     } catch (std::out_of_range& e) {
51854       {
51855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (std::exception& e) {
51858       {
51859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (...) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51864       };
51865     }
51866   }
51867   jresult = (int)result;
51868   return jresult;
51869 }
51870
51871
51872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51873   int jresult ;
51874   int result;
51875
51876   {
51877     try {
51878       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51879     } catch (std::out_of_range& e) {
51880       {
51881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (std::exception& e) {
51884       {
51885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51886       };
51887     } catch (...) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51890       };
51891     }
51892   }
51893   jresult = (int)result;
51894   return jresult;
51895 }
51896
51897
51898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51899   int jresult ;
51900   int result;
51901
51902   {
51903     try {
51904       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51905     } catch (std::out_of_range& e) {
51906       {
51907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51908       };
51909     } catch (std::exception& e) {
51910       {
51911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51912       };
51913     } catch (...) {
51914       {
51915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51916       };
51917     }
51918   }
51919   jresult = (int)result;
51920   return jresult;
51921 }
51922
51923
51924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51925   int jresult ;
51926   int result;
51927
51928   {
51929     try {
51930       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51931     } catch (std::out_of_range& e) {
51932       {
51933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51934       };
51935     } catch (std::exception& e) {
51936       {
51937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51938       };
51939     } catch (...) {
51940       {
51941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51942       };
51943     }
51944   }
51945   jresult = (int)result;
51946   return jresult;
51947 }
51948
51949
51950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51951   int jresult ;
51952   int result;
51953
51954   {
51955     try {
51956       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51968       };
51969     }
51970   }
51971   jresult = (int)result;
51972   return jresult;
51973 }
51974
51975
51976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51977   int jresult ;
51978   int result;
51979
51980   {
51981     try {
51982       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51983     } catch (std::out_of_range& e) {
51984       {
51985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51986       };
51987     } catch (std::exception& e) {
51988       {
51989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51990       };
51991     } catch (...) {
51992       {
51993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51994       };
51995     }
51996   }
51997   jresult = (int)result;
51998   return jresult;
51999 }
52000
52001
52002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
52003   int jresult ;
52004   int result;
52005
52006   {
52007     try {
52008       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
52009     } catch (std::out_of_range& e) {
52010       {
52011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52012       };
52013     } catch (std::exception& e) {
52014       {
52015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52016       };
52017     } catch (...) {
52018       {
52019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52020       };
52021     }
52022   }
52023   jresult = (int)result;
52024   return jresult;
52025 }
52026
52027
52028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
52029   int jresult ;
52030   int result;
52031
52032   {
52033     try {
52034       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
52035     } catch (std::out_of_range& e) {
52036       {
52037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52038       };
52039     } catch (std::exception& e) {
52040       {
52041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52042       };
52043     } catch (...) {
52044       {
52045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52046       };
52047     }
52048   }
52049   jresult = (int)result;
52050   return jresult;
52051 }
52052
52053
52054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52055   int jresult ;
52056   int result;
52057
52058   {
52059     try {
52060       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52061     } catch (std::out_of_range& e) {
52062       {
52063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52064       };
52065     } catch (std::exception& e) {
52066       {
52067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52068       };
52069     } catch (...) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52072       };
52073     }
52074   }
52075   jresult = (int)result;
52076   return jresult;
52077 }
52078
52079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52080   int jresult ;
52081   int result;
52082
52083   {
52084     try {
52085       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
52086     } catch (std::out_of_range& e) {
52087       {
52088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52089       };
52090     } catch (std::exception& e) {
52091       {
52092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52093       };
52094     } catch (...) {
52095       {
52096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52097       };
52098     }
52099   }
52100   jresult = (int)result;
52101   return jresult;
52102 }
52103
52104
52105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52106   int jresult ;
52107   int result;
52108   {
52109     try
52110     {
52111       result = (int)Dali::Toolkit::DevelImageVisual::Property::BATCH_SIZE;
52112     } catch (std::out_of_range& e) {
52113       {
52114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52115       };
52116     } catch (std::exception& e) {
52117       {
52118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52119       };
52120     } catch (...) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52123       };
52124     }
52125   }
52126   jresult = (int)result;
52127   return jresult;
52128 }
52129
52130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52131   int jresult ;
52132   int result;
52133   {
52134     try
52135     {
52136       result = (int)Dali::Toolkit::DevelImageVisual::Property::CACHE_SIZE;
52137     } catch (std::out_of_range& e) {
52138       {
52139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52140       };
52141     } catch (std::exception& e) {
52142       {
52143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52144       };
52145     } catch (...) {
52146       {
52147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52148       };
52149     }
52150   }
52151   jresult = (int)result;
52152   return jresult;
52153 }
52154
52155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52156   int jresult ;
52157   int result;
52158   {
52159     try
52160     {
52161       result = (int)Dali::Toolkit::DevelImageVisual::Property::FRAME_DELAY;
52162     } catch (std::out_of_range& e) {
52163       {
52164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52165       };
52166     } catch (std::exception& e) {
52167       {
52168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52169       };
52170     } catch (...) {
52171       {
52172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52173       };
52174     }
52175   }
52176   jresult = (int)result;
52177   return jresult;
52178 }
52179
52180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52181   int jresult ;
52182   int result;
52183   {
52184     try
52185     {
52186       result = (int)Dali::Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE;
52187     } catch (std::out_of_range& e) {
52188       {
52189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52190       };
52191     } catch (std::exception& e) {
52192       {
52193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52194       };
52195     } catch (...) {
52196       {
52197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52198       };
52199     }
52200   }
52201   jresult = (int)result;
52202   return jresult;
52203 }
52204
52205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52206   int jresult ;
52207   int result;
52208   {
52209     try
52210     {
52211       result = (int)Dali::Toolkit::DevelImageVisual::Property::CROP_TO_MASK;
52212     } catch (std::out_of_range& e) {
52213       {
52214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52215       };
52216     } catch (std::exception& e) {
52217       {
52218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52219       };
52220     } catch (...) {
52221       {
52222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52223       };
52224     }
52225   }
52226   jresult = (int)result;
52227   return jresult;
52228 }
52229
52230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52231   int jresult ;
52232   int result;
52233
52234   {
52235     try {
52236       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52237     } catch (std::out_of_range& e) {
52238       {
52239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52240       };
52241     } catch (std::exception& e) {
52242       {
52243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52244       };
52245     } catch (...) {
52246       {
52247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52248       };
52249     }
52250   }
52251   jresult = (int)result;
52252   return jresult;
52253 }
52254
52255
52256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52257   int jresult ;
52258   int result;
52259
52260   {
52261     try {
52262       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52263     } catch (std::out_of_range& e) {
52264       {
52265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52266       };
52267     } catch (std::exception& e) {
52268       {
52269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52270       };
52271     } catch (...) {
52272       {
52273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52274       };
52275     }
52276   }
52277   jresult = (int)result;
52278   return jresult;
52279 }
52280
52281
52282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52283   int jresult ;
52284   int result;
52285
52286   {
52287     try {
52288       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52289     } catch (std::out_of_range& e) {
52290       {
52291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52292       };
52293     } catch (std::exception& e) {
52294       {
52295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52296       };
52297     } catch (...) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52300       };
52301     }
52302   }
52303   jresult = (int)result;
52304   return jresult;
52305 }
52306
52307
52308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52309   int jresult ;
52310   int result;
52311
52312   {
52313     try {
52314       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52315     } catch (std::out_of_range& e) {
52316       {
52317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52318       };
52319     } catch (std::exception& e) {
52320       {
52321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52322       };
52323     } catch (...) {
52324       {
52325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52326       };
52327     }
52328   }
52329   jresult = (int)result;
52330   return jresult;
52331 }
52332
52333
52334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52335   int jresult ;
52336   int result;
52337
52338   {
52339     try {
52340       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52341     } catch (std::out_of_range& e) {
52342       {
52343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52344       };
52345     } catch (std::exception& e) {
52346       {
52347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52348       };
52349     } catch (...) {
52350       {
52351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52352       };
52353     }
52354   }
52355   jresult = (int)result;
52356   return jresult;
52357 }
52358
52359
52360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52361   int jresult ;
52362   int result;
52363
52364   {
52365     try {
52366       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52367     } catch (std::out_of_range& e) {
52368       {
52369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52370       };
52371     } catch (std::exception& e) {
52372       {
52373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52374       };
52375     } catch (...) {
52376       {
52377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52378       };
52379     }
52380   }
52381   jresult = (int)result;
52382   return jresult;
52383 }
52384
52385
52386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52387   int jresult ;
52388   int result;
52389
52390   {
52391     try {
52392       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52393     } catch (std::out_of_range& e) {
52394       {
52395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52396       };
52397     } catch (std::exception& e) {
52398       {
52399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (...) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52404       };
52405     }
52406   }
52407   jresult = (int)result;
52408   return jresult;
52409 }
52410
52411
52412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52413   int jresult ;
52414   int result;
52415
52416   {
52417     try {
52418       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52419     } catch (std::out_of_range& e) {
52420       {
52421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52422       };
52423     } catch (std::exception& e) {
52424       {
52425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52426       };
52427     } catch (...) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52430       };
52431     }
52432   }
52433   jresult = (int)result;
52434   return jresult;
52435 }
52436
52437
52438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52439   int jresult ;
52440   int result;
52441
52442   {
52443     try {
52444       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52445     } catch (std::out_of_range& e) {
52446       {
52447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52448       };
52449     } catch (std::exception& e) {
52450       {
52451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52452       };
52453     } catch (...) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52456       };
52457     }
52458   }
52459   jresult = (int)result;
52460   return jresult;
52461 }
52462
52463
52464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52465   int jresult ;
52466   int result;
52467
52468   {
52469     try {
52470       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52471     } catch (std::out_of_range& e) {
52472       {
52473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (std::exception& e) {
52476       {
52477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485   jresult = (int)result;
52486   return jresult;
52487 }
52488
52489
52490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52491   int jresult ;
52492   int result;
52493
52494   {
52495     try {
52496       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52497     } catch (std::out_of_range& e) {
52498       {
52499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52500       };
52501     } catch (std::exception& e) {
52502       {
52503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52504       };
52505     } catch (...) {
52506       {
52507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52508       };
52509     }
52510   }
52511   jresult = (int)result;
52512   return jresult;
52513 }
52514
52515
52516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52517   int jresult ;
52518   int result;
52519
52520   {
52521     try {
52522       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52523     } catch (std::out_of_range& e) {
52524       {
52525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52526       };
52527     } catch (std::exception& e) {
52528       {
52529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52530       };
52531     } catch (...) {
52532       {
52533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52534       };
52535     }
52536   }
52537   jresult = (int)result;
52538   return jresult;
52539 }
52540
52541
52542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52543   int jresult ;
52544   int result;
52545
52546   {
52547     try {
52548       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52549     } catch (std::out_of_range& e) {
52550       {
52551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (std::exception& e) {
52554       {
52555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52556       };
52557     } catch (...) {
52558       {
52559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52560       };
52561     }
52562   }
52563   jresult = (int)result;
52564   return jresult;
52565 }
52566
52567
52568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52569   int jresult ;
52570   int result;
52571
52572   {
52573     try {
52574       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52575     } catch (std::out_of_range& e) {
52576       {
52577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52578       };
52579     } catch (std::exception& e) {
52580       {
52581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52582       };
52583     } catch (...) {
52584       {
52585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52586       };
52587     }
52588   }
52589   jresult = (int)result;
52590   return jresult;
52591 }
52592
52593
52594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52595   int jresult ;
52596   int result;
52597
52598   {
52599     try {
52600       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52608       };
52609     } catch (...) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52612       };
52613     }
52614   }
52615   jresult = (int)result;
52616   return jresult;
52617 }
52618
52619
52620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52621   int jresult ;
52622   int result;
52623
52624   {
52625     try {
52626       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52627     } catch (std::out_of_range& e) {
52628       {
52629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (std::exception& e) {
52632       {
52633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52634       };
52635     } catch (...) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52638       };
52639     }
52640   }
52641   jresult = (int)result;
52642   return jresult;
52643 }
52644
52645
52646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52647   int jresult ;
52648   int result;
52649
52650   {
52651     try {
52652       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52653     } catch (std::out_of_range& e) {
52654       {
52655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52656       };
52657     } catch (std::exception& e) {
52658       {
52659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52660       };
52661     } catch (...) {
52662       {
52663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52664       };
52665     }
52666   }
52667   jresult = (int)result;
52668   return jresult;
52669 }
52670
52671
52672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52673   int jresult ;
52674   int result;
52675
52676   {
52677     try {
52678       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52679     } catch (std::out_of_range& e) {
52680       {
52681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52682       };
52683     } catch (std::exception& e) {
52684       {
52685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52690       };
52691     }
52692   }
52693   jresult = (int)result;
52694   return jresult;
52695 }
52696
52697
52698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52699   int jresult ;
52700   int result;
52701
52702   {
52703     try {
52704       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52712       };
52713     } catch (...) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52716       };
52717     }
52718   }
52719   jresult = (int)result;
52720   return jresult;
52721 }
52722
52723
52724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52725   int jresult ;
52726   int result;
52727
52728   {
52729     try {
52730       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52731     } catch (std::out_of_range& e) {
52732       {
52733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52734       };
52735     } catch (std::exception& e) {
52736       {
52737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52738       };
52739     } catch (...) {
52740       {
52741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52742       };
52743     }
52744   }
52745   jresult = (int)result;
52746   return jresult;
52747 }
52748
52749
52750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52751   int jresult ;
52752   int result;
52753
52754   {
52755     try {
52756       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52757     } catch (std::out_of_range& e) {
52758       {
52759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52760       };
52761     } catch (std::exception& e) {
52762       {
52763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52764       };
52765     } catch (...) {
52766       {
52767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52768       };
52769     }
52770   }
52771   jresult = (int)result;
52772   return jresult;
52773 }
52774
52775
52776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52777   int jresult ;
52778   int result;
52779
52780   {
52781     try {
52782       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52790       };
52791     } catch (...) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52794       };
52795     }
52796   }
52797   jresult = (int)result;
52798   return jresult;
52799 }
52800
52801
52802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52803   int jresult ;
52804   int result;
52805
52806   {
52807     try {
52808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (...) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52820       };
52821     }
52822   }
52823   jresult = (int)result;
52824   return jresult;
52825 }
52826
52827
52828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52829   int jresult ;
52830   int result;
52831
52832   {
52833     try {
52834       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52835     } catch (std::out_of_range& e) {
52836       {
52837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52838       };
52839     } catch (std::exception& e) {
52840       {
52841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52842       };
52843     } catch (...) {
52844       {
52845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52846       };
52847     }
52848   }
52849   jresult = (int)result;
52850   return jresult;
52851 }
52852
52853
52854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52855   int jresult ;
52856   int result;
52857
52858   {
52859     try {
52860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52861     } catch (std::out_of_range& e) {
52862       {
52863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52864       };
52865     } catch (std::exception& e) {
52866       {
52867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52868       };
52869     } catch (...) {
52870       {
52871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52872       };
52873     }
52874   }
52875   jresult = (int)result;
52876   return jresult;
52877 }
52878
52879
52880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52881   int jresult ;
52882   int result;
52883
52884   {
52885     try {
52886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52887     } catch (std::out_of_range& e) {
52888       {
52889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52890       };
52891     } catch (std::exception& e) {
52892       {
52893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52898       };
52899     }
52900   }
52901   jresult = (int)result;
52902   return jresult;
52903 }
52904
52905
52906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52907   int jresult ;
52908   int result;
52909
52910   {
52911     try {
52912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52913     } catch (std::out_of_range& e) {
52914       {
52915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52916       };
52917     } catch (std::exception& e) {
52918       {
52919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52920       };
52921     } catch (...) {
52922       {
52923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52924       };
52925     }
52926   }
52927   jresult = (int)result;
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52933   int jresult ;
52934   int result;
52935
52936   {
52937     try {
52938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52950       };
52951     }
52952   }
52953   jresult = (int)result;
52954   return jresult;
52955 }
52956
52957
52958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52959   int jresult ;
52960   int result;
52961
52962   {
52963     try {
52964       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52965     } catch (std::out_of_range& e) {
52966       {
52967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52968       };
52969     } catch (std::exception& e) {
52970       {
52971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52972       };
52973     } catch (...) {
52974       {
52975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52976       };
52977     }
52978   }
52979   jresult = (int)result;
52980   return jresult;
52981 }
52982
52983
52984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52985   int jresult ;
52986   int result;
52987
52988   {
52989     try {
52990       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52991     } catch (std::out_of_range& e) {
52992       {
52993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52994       };
52995     } catch (std::exception& e) {
52996       {
52997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52998       };
52999     } catch (...) {
53000       {
53001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53002       };
53003     }
53004   }
53005   jresult = (int)result;
53006   return jresult;
53007 }
53008
53009
53010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
53011   int jresult ;
53012   int result;
53013
53014   {
53015     try {
53016       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
53017     } catch (std::out_of_range& e) {
53018       {
53019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53020       };
53021     } catch (std::exception& e) {
53022       {
53023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53024       };
53025     } catch (...) {
53026       {
53027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53028       };
53029     }
53030   }
53031   jresult = (int)result;
53032   return jresult;
53033 }
53034
53035
53036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
53037   int jresult ;
53038   int result;
53039
53040   {
53041     try {
53042       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53050       };
53051     } catch (...) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53054       };
53055     }
53056   }
53057   jresult = (int)result;
53058   return jresult;
53059 }
53060
53061
53062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53063   int jresult ;
53064   int result;
53065
53066   {
53067     try {
53068       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53069     } catch (std::out_of_range& e) {
53070       {
53071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53072       };
53073     } catch (std::exception& e) {
53074       {
53075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53076       };
53077     } catch (...) {
53078       {
53079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53080       };
53081     }
53082   }
53083   jresult = (int)result;
53084   return jresult;
53085 }
53086
53087
53088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53089   int jresult ;
53090   int result;
53091
53092   {
53093     try {
53094       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53095     } catch (std::out_of_range& e) {
53096       {
53097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53098       };
53099     } catch (std::exception& e) {
53100       {
53101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53102       };
53103     } catch (...) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53106       };
53107     }
53108   }
53109   jresult = (int)result;
53110   return jresult;
53111 }
53112
53113
53114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53115   int jresult ;
53116   int result;
53117
53118   {
53119     try {
53120       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53121     } catch (std::out_of_range& e) {
53122       {
53123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53124       };
53125     } catch (std::exception& e) {
53126       {
53127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53128       };
53129     } catch (...) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53132       };
53133     }
53134   }
53135   jresult = (int)result;
53136   return jresult;
53137 }
53138
53139
53140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53141   int jresult ;
53142   int result;
53143
53144   {
53145     try {
53146       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53147     } catch (std::out_of_range& e) {
53148       {
53149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53150       };
53151     } catch (std::exception& e) {
53152       {
53153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53154       };
53155     } catch (...) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53158       };
53159     }
53160   }
53161   jresult = (int)result;
53162   return jresult;
53163 }
53164
53165
53166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53167   int jresult ;
53168   int result;
53169
53170   {
53171     try {
53172       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53173     } catch (std::out_of_range& e) {
53174       {
53175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53176       };
53177     } catch (std::exception& e) {
53178       {
53179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53180       };
53181     } catch (...) {
53182       {
53183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53184       };
53185     }
53186   }
53187   jresult = (int)result;
53188   return jresult;
53189 }
53190
53191
53192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53193   void * jresult ;
53194   Dali::Toolkit::Builder *result = 0 ;
53195
53196   {
53197     try {
53198       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53199     } catch (std::out_of_range& e) {
53200       {
53201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53202       };
53203     } catch (std::exception& e) {
53204       {
53205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53206       };
53207     } catch (...) {
53208       {
53209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53210       };
53211     }
53212   }
53213   jresult = (void *)result;
53214   return jresult;
53215 }
53216
53217
53218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53219   void * jresult ;
53220   Dali::Toolkit::Builder result;
53221
53222   {
53223     try {
53224       result = Dali::Toolkit::Builder::New();
53225     } catch (std::out_of_range& e) {
53226       {
53227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53228       };
53229     } catch (std::exception& e) {
53230       {
53231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53232       };
53233     } catch (...) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53236       };
53237     }
53238   }
53239   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53240   return jresult;
53241 }
53242
53243
53244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53245   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53246
53247   arg1 = (Dali::Toolkit::Builder *)jarg1;
53248   {
53249     try {
53250       delete arg1;
53251     } catch (std::out_of_range& e) {
53252       {
53253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53254       };
53255     } catch (std::exception& e) {
53256       {
53257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53258       };
53259     } catch (...) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53262       };
53263     }
53264   }
53265 }
53266
53267
53268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53269   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53270   std::string *arg2 = 0 ;
53271   Dali::Toolkit::Builder::UIFormat arg3 ;
53272
53273   arg1 = (Dali::Toolkit::Builder *)jarg1;
53274   if (!jarg2) {
53275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53276     return ;
53277   }
53278   std::string arg2_str(jarg2);
53279   arg2 = &arg2_str;
53280   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53281   {
53282     try {
53283       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53284     } catch (std::out_of_range& e) {
53285       {
53286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53287       };
53288     } catch (std::exception& e) {
53289       {
53290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53291       };
53292     } catch (...) {
53293       {
53294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53295       };
53296     }
53297   }
53298
53299   //argout typemap for const std::string&
53300
53301 }
53302
53303
53304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53305   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53306   std::string *arg2 = 0 ;
53307
53308   arg1 = (Dali::Toolkit::Builder *)jarg1;
53309   if (!jarg2) {
53310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53311     return ;
53312   }
53313   std::string arg2_str(jarg2);
53314   arg2 = &arg2_str;
53315   {
53316     try {
53317       (arg1)->LoadFromString((std::string const &)*arg2);
53318     } catch (std::out_of_range& e) {
53319       {
53320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53321       };
53322     } catch (std::exception& e) {
53323       {
53324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53325       };
53326     } catch (...) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53329       };
53330     }
53331   }
53332
53333   //argout typemap for const std::string&
53334
53335 }
53336
53337
53338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53339   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53340   Dali::Property::Map *arg2 = 0 ;
53341
53342   arg1 = (Dali::Toolkit::Builder *)jarg1;
53343   arg2 = (Dali::Property::Map *)jarg2;
53344   if (!arg2) {
53345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53346     return ;
53347   }
53348   {
53349     try {
53350       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53351     } catch (std::out_of_range& e) {
53352       {
53353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53354       };
53355     } catch (std::exception& e) {
53356       {
53357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (...) {
53360       {
53361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53362       };
53363     }
53364   }
53365 }
53366
53367
53368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53369   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53370   std::string *arg2 = 0 ;
53371   Dali::Property::Value *arg3 = 0 ;
53372
53373   arg1 = (Dali::Toolkit::Builder *)jarg1;
53374   if (!jarg2) {
53375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53376     return ;
53377   }
53378   std::string arg2_str(jarg2);
53379   arg2 = &arg2_str;
53380   arg3 = (Dali::Property::Value *)jarg3;
53381   if (!arg3) {
53382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53383     return ;
53384   }
53385   {
53386     try {
53387       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53388     } catch (std::out_of_range& e) {
53389       {
53390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (std::exception& e) {
53393       {
53394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (...) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53399       };
53400     }
53401   }
53402
53403   //argout typemap for const std::string&
53404
53405 }
53406
53407
53408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53409   void * jresult ;
53410   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53411   Dali::Property::Map *result = 0 ;
53412
53413   arg1 = (Dali::Toolkit::Builder *)jarg1;
53414   {
53415     try {
53416       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53417     } catch (std::out_of_range& e) {
53418       {
53419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53420       };
53421     } catch (std::exception& e) {
53422       {
53423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53424       };
53425     } catch (...) {
53426       {
53427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53428       };
53429     }
53430   }
53431   jresult = (void *)result;
53432   return jresult;
53433 }
53434
53435
53436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53437   void * jresult ;
53438   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53439   std::string *arg2 = 0 ;
53440   Dali::Property::Value *result = 0 ;
53441
53442   arg1 = (Dali::Toolkit::Builder *)jarg1;
53443   if (!jarg2) {
53444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53445     return 0;
53446   }
53447   std::string arg2_str(jarg2);
53448   arg2 = &arg2_str;
53449   {
53450     try {
53451       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53452     } catch (std::out_of_range& e) {
53453       {
53454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53455       };
53456     } catch (std::exception& e) {
53457       {
53458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53459       };
53460     } catch (...) {
53461       {
53462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53463       };
53464     }
53465   }
53466   jresult = (void *)result;
53467
53468   //argout typemap for const std::string&
53469
53470   return jresult;
53471 }
53472
53473
53474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53475   void * jresult ;
53476   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53477   std::string *arg2 = 0 ;
53478   Dali::Animation result;
53479
53480   arg1 = (Dali::Toolkit::Builder *)jarg1;
53481   if (!jarg2) {
53482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53483     return 0;
53484   }
53485   std::string arg2_str(jarg2);
53486   arg2 = &arg2_str;
53487   {
53488     try {
53489       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53490     } catch (std::out_of_range& e) {
53491       {
53492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53493       };
53494     } catch (std::exception& e) {
53495       {
53496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53497       };
53498     } catch (...) {
53499       {
53500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53501       };
53502     }
53503   }
53504   jresult = new Dali::Animation((const Dali::Animation &)result);
53505
53506   //argout typemap for const std::string&
53507
53508   return jresult;
53509 }
53510
53511
53512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53513   void * jresult ;
53514   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53515   std::string *arg2 = 0 ;
53516   Dali::Property::Map *arg3 = 0 ;
53517   Dali::Animation result;
53518
53519   arg1 = (Dali::Toolkit::Builder *)jarg1;
53520   if (!jarg2) {
53521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53522     return 0;
53523   }
53524   std::string arg2_str(jarg2);
53525   arg2 = &arg2_str;
53526   arg3 = (Dali::Property::Map *)jarg3;
53527   if (!arg3) {
53528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53529     return 0;
53530   }
53531   {
53532     try {
53533       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53534     } catch (std::out_of_range& e) {
53535       {
53536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53537       };
53538     } catch (std::exception& e) {
53539       {
53540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53541       };
53542     } catch (...) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53545       };
53546     }
53547   }
53548   jresult = new Dali::Animation((const Dali::Animation &)result);
53549
53550   //argout typemap for const std::string&
53551
53552   return jresult;
53553 }
53554
53555
53556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53557   void * jresult ;
53558   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53559   std::string *arg2 = 0 ;
53560   Dali::Actor arg3 ;
53561   Dali::Actor *argp3 ;
53562   Dali::Animation result;
53563
53564   arg1 = (Dali::Toolkit::Builder *)jarg1;
53565   if (!jarg2) {
53566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53567     return 0;
53568   }
53569   std::string arg2_str(jarg2);
53570   arg2 = &arg2_str;
53571   argp3 = (Dali::Actor *)jarg3;
53572   if (!argp3) {
53573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53574     return 0;
53575   }
53576   arg3 = *argp3;
53577   {
53578     try {
53579       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53580     } catch (std::out_of_range& e) {
53581       {
53582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53583       };
53584     } catch (std::exception& e) {
53585       {
53586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53587       };
53588     } catch (...) {
53589       {
53590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53591       };
53592     }
53593   }
53594   jresult = new Dali::Animation((const Dali::Animation &)result);
53595
53596   //argout typemap for const std::string&
53597
53598   return jresult;
53599 }
53600
53601
53602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53603   void * jresult ;
53604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53605   std::string *arg2 = 0 ;
53606   Dali::Property::Map *arg3 = 0 ;
53607   Dali::Actor arg4 ;
53608   Dali::Actor *argp4 ;
53609   Dali::Animation result;
53610
53611   arg1 = (Dali::Toolkit::Builder *)jarg1;
53612   if (!jarg2) {
53613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53614     return 0;
53615   }
53616   std::string arg2_str(jarg2);
53617   arg2 = &arg2_str;
53618   arg3 = (Dali::Property::Map *)jarg3;
53619   if (!arg3) {
53620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53621     return 0;
53622   }
53623   argp4 = (Dali::Actor *)jarg4;
53624   if (!argp4) {
53625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53626     return 0;
53627   }
53628   arg4 = *argp4;
53629   {
53630     try {
53631       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53632     } catch (std::out_of_range& e) {
53633       {
53634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53635       };
53636     } catch (std::exception& e) {
53637       {
53638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53639       };
53640     } catch (...) {
53641       {
53642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53643       };
53644     }
53645   }
53646   jresult = new Dali::Animation((const Dali::Animation &)result);
53647
53648   //argout typemap for const std::string&
53649
53650   return jresult;
53651 }
53652
53653
53654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53655   void * jresult ;
53656   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53657   std::string *arg2 = 0 ;
53658   Dali::BaseHandle result;
53659
53660   arg1 = (Dali::Toolkit::Builder *)jarg1;
53661   if (!jarg2) {
53662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53663     return 0;
53664   }
53665   std::string arg2_str(jarg2);
53666   arg2 = &arg2_str;
53667   {
53668     try {
53669       result = (arg1)->Create((std::string const &)*arg2);
53670     } catch (std::out_of_range& e) {
53671       {
53672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53673       };
53674     } catch (std::exception& e) {
53675       {
53676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53677       };
53678     } catch (...) {
53679       {
53680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53681       };
53682     }
53683   }
53684   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53685
53686   //argout typemap for const std::string&
53687
53688   return jresult;
53689 }
53690
53691
53692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53693   void * jresult ;
53694   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53695   std::string *arg2 = 0 ;
53696   Dali::Property::Map *arg3 = 0 ;
53697   Dali::BaseHandle result;
53698
53699   arg1 = (Dali::Toolkit::Builder *)jarg1;
53700   if (!jarg2) {
53701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53702     return 0;
53703   }
53704   std::string arg2_str(jarg2);
53705   arg2 = &arg2_str;
53706   arg3 = (Dali::Property::Map *)jarg3;
53707   if (!arg3) {
53708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53709     return 0;
53710   }
53711   {
53712     try {
53713       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53714     } catch (std::out_of_range& e) {
53715       {
53716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53717       };
53718     } catch (std::exception& e) {
53719       {
53720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53721       };
53722     } catch (...) {
53723       {
53724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53725       };
53726     }
53727   }
53728   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53729
53730   //argout typemap for const std::string&
53731
53732   return jresult;
53733 }
53734
53735
53736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53737   void * jresult ;
53738   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53739   std::string *arg2 = 0 ;
53740   Dali::BaseHandle result;
53741
53742   arg1 = (Dali::Toolkit::Builder *)jarg1;
53743   if (!jarg2) {
53744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53745     return 0;
53746   }
53747   std::string arg2_str(jarg2);
53748   arg2 = &arg2_str;
53749   {
53750     try {
53751       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53763       };
53764     }
53765   }
53766   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53767
53768   //argout typemap for const std::string&
53769
53770   return jresult;
53771 }
53772
53773
53774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53775   unsigned int jresult ;
53776   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53777   std::string *arg2 = 0 ;
53778   Dali::Handle *arg3 = 0 ;
53779   bool result;
53780
53781   arg1 = (Dali::Toolkit::Builder *)jarg1;
53782   if (!jarg2) {
53783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53784     return 0;
53785   }
53786   std::string arg2_str(jarg2);
53787   arg2 = &arg2_str;
53788   arg3 = (Dali::Handle *)jarg3;
53789   if (!arg3) {
53790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53791     return 0;
53792   }
53793   {
53794     try {
53795       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53796     } catch (std::out_of_range& e) {
53797       {
53798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53799       };
53800     } catch (std::exception& e) {
53801       {
53802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53803       };
53804     } catch (...) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53807       };
53808     }
53809   }
53810   jresult = result;
53811
53812   //argout typemap for const std::string&
53813
53814   return jresult;
53815 }
53816
53817
53818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53819   unsigned int jresult ;
53820   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53821   Dali::Handle *arg2 = 0 ;
53822   std::string *arg3 = 0 ;
53823   bool result;
53824
53825   arg1 = (Dali::Toolkit::Builder *)jarg1;
53826   arg2 = (Dali::Handle *)jarg2;
53827   if (!arg2) {
53828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53829     return 0;
53830   }
53831   if (!jarg3) {
53832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53833     return 0;
53834   }
53835   std::string arg3_str(jarg3);
53836   arg3 = &arg3_str;
53837   {
53838     try {
53839       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53840     } catch (std::out_of_range& e) {
53841       {
53842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53843       };
53844     } catch (std::exception& e) {
53845       {
53846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53847       };
53848     } catch (...) {
53849       {
53850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53851       };
53852     }
53853   }
53854   jresult = result;
53855
53856   //argout typemap for const std::string&
53857
53858   return jresult;
53859 }
53860
53861
53862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53863   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53864   Dali::Actor arg2 ;
53865   Dali::Actor *argp2 ;
53866
53867   arg1 = (Dali::Toolkit::Builder *)jarg1;
53868   argp2 = (Dali::Actor *)jarg2;
53869   if (!argp2) {
53870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53871     return ;
53872   }
53873   arg2 = *argp2;
53874   {
53875     try {
53876       (arg1)->AddActors(arg2);
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53888       };
53889     }
53890   }
53891 }
53892
53893
53894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53895   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53896   std::string *arg2 = 0 ;
53897   Dali::Actor arg3 ;
53898   Dali::Actor *argp3 ;
53899
53900   arg1 = (Dali::Toolkit::Builder *)jarg1;
53901   if (!jarg2) {
53902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53903     return ;
53904   }
53905   std::string arg2_str(jarg2);
53906   arg2 = &arg2_str;
53907   argp3 = (Dali::Actor *)jarg3;
53908   if (!argp3) {
53909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53910     return ;
53911   }
53912   arg3 = *argp3;
53913   {
53914     try {
53915       (arg1)->AddActors((std::string const &)*arg2,arg3);
53916     } catch (std::out_of_range& e) {
53917       {
53918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53919       };
53920     } catch (std::exception& e) {
53921       {
53922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53923       };
53924     } catch (...) {
53925       {
53926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53927       };
53928     }
53929   }
53930
53931   //argout typemap for const std::string&
53932
53933 }
53934
53935
53936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53937   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53938   std::string *arg2 = 0 ;
53939
53940   arg1 = (Dali::Toolkit::Builder *)jarg1;
53941   if (!jarg2) {
53942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53943     return ;
53944   }
53945   std::string arg2_str(jarg2);
53946   arg2 = &arg2_str;
53947   {
53948     try {
53949       (arg1)->CreateRenderTask((std::string const &)*arg2);
53950     } catch (std::out_of_range& e) {
53951       {
53952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53953       };
53954     } catch (std::exception& e) {
53955       {
53956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53957       };
53958     } catch (...) {
53959       {
53960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53961       };
53962     }
53963   }
53964
53965   //argout typemap for const std::string&
53966
53967 }
53968
53969
53970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53971   void * jresult ;
53972   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53973   std::string *arg2 = 0 ;
53974   Dali::FrameBufferImage result;
53975
53976   arg1 = (Dali::Toolkit::Builder *)jarg1;
53977   if (!jarg2) {
53978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53979     return 0;
53980   }
53981   std::string arg2_str(jarg2);
53982   arg2 = &arg2_str;
53983   {
53984     try {
53985       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53986     } catch (std::out_of_range& e) {
53987       {
53988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53989       };
53990     } catch (std::exception& e) {
53991       {
53992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53993       };
53994     } catch (...) {
53995       {
53996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53997       };
53998     }
53999   }
54000   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
54001
54002   //argout typemap for const std::string&
54003
54004   return jresult;
54005 }
54006
54007
54008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
54009   void * jresult ;
54010   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54011   std::string *arg2 = 0 ;
54012   Dali::Path result;
54013
54014   arg1 = (Dali::Toolkit::Builder *)jarg1;
54015   if (!jarg2) {
54016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54017     return 0;
54018   }
54019   std::string arg2_str(jarg2);
54020   arg2 = &arg2_str;
54021   {
54022     try {
54023       result = (arg1)->GetPath((std::string const &)*arg2);
54024     } catch (std::out_of_range& e) {
54025       {
54026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54027       };
54028     } catch (std::exception& e) {
54029       {
54030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54031       };
54032     } catch (...) {
54033       {
54034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54035       };
54036     }
54037   }
54038   jresult = new Dali::Path((const Dali::Path &)result);
54039
54040   //argout typemap for const std::string&
54041
54042   return jresult;
54043 }
54044
54045
54046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54047   void * jresult ;
54048   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54049   std::string *arg2 = 0 ;
54050   Dali::PathConstrainer result;
54051
54052   arg1 = (Dali::Toolkit::Builder *)jarg1;
54053   if (!jarg2) {
54054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54055     return 0;
54056   }
54057   std::string arg2_str(jarg2);
54058   arg2 = &arg2_str;
54059   {
54060     try {
54061       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54062     } catch (std::out_of_range& e) {
54063       {
54064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54065       };
54066     } catch (std::exception& e) {
54067       {
54068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54073       };
54074     }
54075   }
54076   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54077
54078   //argout typemap for const std::string&
54079
54080   return jresult;
54081 }
54082
54083
54084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54085   void * jresult ;
54086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54087   std::string *arg2 = 0 ;
54088   Dali::LinearConstrainer result;
54089
54090   arg1 = (Dali::Toolkit::Builder *)jarg1;
54091   if (!jarg2) {
54092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54093     return 0;
54094   }
54095   std::string arg2_str(jarg2);
54096   arg2 = &arg2_str;
54097   {
54098     try {
54099       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54100     } catch (std::out_of_range& e) {
54101       {
54102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54103       };
54104     } catch (std::exception& e) {
54105       {
54106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54107       };
54108     } catch (...) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54111       };
54112     }
54113   }
54114   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54115
54116   //argout typemap for const std::string&
54117
54118   return jresult;
54119 }
54120
54121
54122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54123   void * jresult ;
54124   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54125   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54126
54127   arg1 = (Dali::Toolkit::Builder *)jarg1;
54128   {
54129     try {
54130       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54131     } catch (std::out_of_range& e) {
54132       {
54133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54134       };
54135     } catch (std::exception& e) {
54136       {
54137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54138       };
54139     } catch (...) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54142       };
54143     }
54144   }
54145   jresult = (void *)result;
54146   return jresult;
54147 }
54148
54149
54150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54151   void * jresult ;
54152   Dali::Toolkit::TransitionData *result = 0 ;
54153
54154   {
54155     try {
54156       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54157     } catch (std::out_of_range& e) {
54158       {
54159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54160       };
54161     } catch (std::exception& e) {
54162       {
54163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54164       };
54165     } catch (...) {
54166       {
54167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54168       };
54169     }
54170   }
54171   jresult = (void *)result;
54172   return jresult;
54173 }
54174
54175
54176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54177   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54178
54179   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54180   {
54181     try {
54182       delete arg1;
54183     } catch (std::out_of_range& e) {
54184       {
54185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54186       };
54187     } catch (std::exception& e) {
54188       {
54189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54190       };
54191     } catch (...) {
54192       {
54193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54194       };
54195     }
54196   }
54197 }
54198
54199
54200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54201   void * jresult ;
54202   Dali::Property::Map *arg1 = 0 ;
54203   Dali::Toolkit::TransitionData result;
54204
54205   arg1 = (Dali::Property::Map *)jarg1;
54206   if (!arg1) {
54207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54208     return 0;
54209   }
54210   {
54211     try {
54212       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54213     } catch (std::out_of_range& e) {
54214       {
54215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (std::exception& e) {
54218       {
54219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54220       };
54221     } catch (...) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54224       };
54225     }
54226   }
54227   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54228   return jresult;
54229 }
54230
54231
54232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54233   void * jresult ;
54234   Dali::Property::Array *arg1 = 0 ;
54235   Dali::Toolkit::TransitionData result;
54236
54237   arg1 = (Dali::Property::Array *)jarg1;
54238   if (!arg1) {
54239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54240     return 0;
54241   }
54242   {
54243     try {
54244       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (...) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54256       };
54257     }
54258   }
54259   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54260   return jresult;
54261 }
54262
54263
54264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54265   void * jresult ;
54266   Dali::BaseHandle arg1 ;
54267   Dali::BaseHandle *argp1 ;
54268   Dali::Toolkit::TransitionData result;
54269
54270   argp1 = (Dali::BaseHandle *)jarg1;
54271   if (!argp1) {
54272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54273     return 0;
54274   }
54275   arg1 = *argp1;
54276   {
54277     try {
54278       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54279     } catch (std::out_of_range& e) {
54280       {
54281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54282       };
54283     } catch (std::exception& e) {
54284       {
54285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54286       };
54287     } catch (...) {
54288       {
54289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54290       };
54291     }
54292   }
54293   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54294   return jresult;
54295 }
54296
54297
54298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54299   void * jresult ;
54300   Dali::Toolkit::TransitionData *arg1 = 0 ;
54301   Dali::Toolkit::TransitionData *result = 0 ;
54302
54303   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54304   if (!arg1) {
54305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54306     return 0;
54307   }
54308   {
54309     try {
54310       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54311     } catch (std::out_of_range& e) {
54312       {
54313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54314       };
54315     } catch (std::exception& e) {
54316       {
54317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54322       };
54323     }
54324   }
54325   jresult = (void *)result;
54326   return jresult;
54327 }
54328
54329
54330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54331   void * jresult ;
54332   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54333   Dali::Toolkit::TransitionData *arg2 = 0 ;
54334   Dali::Toolkit::TransitionData *result = 0 ;
54335
54336   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54337   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54338   if (!arg2) {
54339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54340     return 0;
54341   }
54342   {
54343     try {
54344       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54345     } catch (std::out_of_range& e) {
54346       {
54347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (std::exception& e) {
54350       {
54351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (...) {
54354       {
54355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54356       };
54357     }
54358   }
54359   jresult = (void *)result;
54360   return jresult;
54361 }
54362
54363
54364 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54365   unsigned long jresult ;
54366   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54367   size_t result;
54368
54369   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54370   {
54371     try {
54372       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54373     } catch (std::out_of_range& e) {
54374       {
54375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54376       };
54377     } catch (std::exception& e) {
54378       {
54379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54380       };
54381     } catch (...) {
54382       {
54383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54384       };
54385     }
54386   }
54387   jresult = (unsigned long)result;
54388   return jresult;
54389 }
54390
54391
54392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54393   void * jresult ;
54394   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54395   size_t arg2 ;
54396   Dali::Property::Map result;
54397
54398   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54399   arg2 = (size_t)jarg2;
54400   {
54401     try {
54402       result = (arg1)->GetAnimatorAt(arg2);
54403     } catch (std::out_of_range& e) {
54404       {
54405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54406       };
54407     } catch (std::exception& e) {
54408       {
54409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54410       };
54411     } catch (...) {
54412       {
54413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54414       };
54415     }
54416   }
54417   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54418   return jresult;
54419 }
54420
54421
54422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54423   void * jresult ;
54424   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54425   Dali::Toolkit::TransitionData *result = 0 ;
54426
54427   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54428   {
54429     try {
54430       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54431     } catch (std::out_of_range& e) {
54432       {
54433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54434       };
54435     } catch (std::exception& e) {
54436       {
54437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54438       };
54439     } catch (...) {
54440       {
54441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54442       };
54443     }
54444   }
54445   jresult = (void *)result;
54446   return jresult;
54447 }
54448
54449
54450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54451   int jresult ;
54452   int result;
54453
54454   {
54455     try {
54456       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54457     } catch (std::out_of_range& e) {
54458       {
54459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54460       };
54461     } catch (std::exception& e) {
54462       {
54463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54464       };
54465     } catch (...) {
54466       {
54467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54468       };
54469     }
54470   }
54471   jresult = (int)result;
54472   return jresult;
54473 }
54474
54475
54476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54477   int jresult ;
54478   int result;
54479
54480   {
54481     try {
54482       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54483     } catch (std::out_of_range& e) {
54484       {
54485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54486       };
54487     } catch (std::exception& e) {
54488       {
54489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (...) {
54492       {
54493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54494       };
54495     }
54496   }
54497   jresult = (int)result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54503   int jresult ;
54504   int result;
54505
54506   {
54507     try {
54508       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54509     } catch (std::out_of_range& e) {
54510       {
54511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (std::exception& e) {
54514       {
54515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54516       };
54517     } catch (...) {
54518       {
54519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54520       };
54521     }
54522   }
54523   jresult = (int)result;
54524   return jresult;
54525 }
54526
54527
54528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54529   int jresult ;
54530   int result;
54531
54532   {
54533     try {
54534       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54535     } catch (std::out_of_range& e) {
54536       {
54537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54538       };
54539     } catch (std::exception& e) {
54540       {
54541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (...) {
54544       {
54545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54546       };
54547     }
54548   }
54549   jresult = (int)result;
54550   return jresult;
54551 }
54552
54553
54554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54555   int jresult ;
54556   int result;
54557
54558   {
54559     try {
54560       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54561     } catch (std::out_of_range& e) {
54562       {
54563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54564       };
54565     } catch (std::exception& e) {
54566       {
54567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (...) {
54570       {
54571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54572       };
54573     }
54574   }
54575   jresult = (int)result;
54576   return jresult;
54577 }
54578
54579
54580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54581   int jresult ;
54582   int result;
54583
54584   {
54585     try {
54586       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54587     } catch (std::out_of_range& e) {
54588       {
54589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54590       };
54591     } catch (std::exception& e) {
54592       {
54593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54594       };
54595     } catch (...) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54598       };
54599     }
54600   }
54601   jresult = (int)result;
54602   return jresult;
54603 }
54604
54605
54606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54607   int jresult ;
54608   int result;
54609
54610   {
54611     try {
54612       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54613     } catch (std::out_of_range& e) {
54614       {
54615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54616       };
54617     } catch (std::exception& e) {
54618       {
54619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54620       };
54621     } catch (...) {
54622       {
54623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54624       };
54625     }
54626   }
54627   jresult = (int)result;
54628   return jresult;
54629 }
54630
54631
54632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54633   int jresult ;
54634   int result;
54635
54636   {
54637     try {
54638       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54639     } catch (std::out_of_range& e) {
54640       {
54641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54642       };
54643     } catch (std::exception& e) {
54644       {
54645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54646       };
54647     } catch (...) {
54648       {
54649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54650       };
54651     }
54652   }
54653   jresult = (int)result;
54654   return jresult;
54655 }
54656
54657
54658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54659   int jresult ;
54660   int result;
54661
54662   {
54663     try {
54664       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54665     } catch (std::out_of_range& e) {
54666       {
54667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54668       };
54669     } catch (std::exception& e) {
54670       {
54671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54672       };
54673     } catch (...) {
54674       {
54675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54676       };
54677     }
54678   }
54679   jresult = (int)result;
54680   return jresult;
54681 }
54682
54683
54684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54685   int jresult ;
54686   int result;
54687
54688   {
54689     try {
54690       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54691     } catch (std::out_of_range& e) {
54692       {
54693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (std::exception& e) {
54696       {
54697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54698       };
54699     } catch (...) {
54700       {
54701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54702       };
54703     }
54704   }
54705   jresult = (int)result;
54706   return jresult;
54707 }
54708
54709
54710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54711   int jresult ;
54712   int result;
54713
54714   {
54715     try {
54716       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54717     } catch (std::out_of_range& e) {
54718       {
54719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54720       };
54721     } catch (std::exception& e) {
54722       {
54723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54724       };
54725     } catch (...) {
54726       {
54727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54728       };
54729     }
54730   }
54731   jresult = (int)result;
54732   return jresult;
54733 }
54734
54735
54736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54737   int jresult ;
54738   int result;
54739
54740   {
54741     try {
54742       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54743     } catch (std::out_of_range& e) {
54744       {
54745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54746       };
54747     } catch (std::exception& e) {
54748       {
54749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (...) {
54752       {
54753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54754       };
54755     }
54756   }
54757   jresult = (int)result;
54758   return jresult;
54759 }
54760
54761
54762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54763   int jresult ;
54764   int result;
54765
54766   {
54767     try {
54768       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54769     } catch (std::out_of_range& e) {
54770       {
54771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54772       };
54773     } catch (std::exception& e) {
54774       {
54775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54776       };
54777     } catch (...) {
54778       {
54779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54780       };
54781     }
54782   }
54783   jresult = (int)result;
54784   return jresult;
54785 }
54786
54787
54788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54789   int jresult ;
54790   int result;
54791
54792   {
54793     try {
54794       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54795     } catch (std::out_of_range& e) {
54796       {
54797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54798       };
54799     } catch (std::exception& e) {
54800       {
54801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54802       };
54803     } catch (...) {
54804       {
54805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54806       };
54807     }
54808   }
54809   jresult = (int)result;
54810   return jresult;
54811 }
54812
54813
54814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54815   void * jresult ;
54816   Dali::Toolkit::Control result;
54817
54818   {
54819     try {
54820       result = Dali::Toolkit::Internal::Control::New();
54821     } catch (std::out_of_range& e) {
54822       {
54823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54824       };
54825     } catch (std::exception& e) {
54826       {
54827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54828       };
54829     } catch (...) {
54830       {
54831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54832       };
54833     }
54834   }
54835   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54836   return jresult;
54837 }
54838
54839
54840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54842   std::string *arg2 = 0 ;
54843
54844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54845   if (!jarg2) {
54846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54847     return ;
54848   }
54849   std::string arg2_str(jarg2);
54850   arg2 = &arg2_str;
54851   {
54852     try {
54853       (arg1)->SetStyleName((std::string const &)*arg2);
54854     } catch (std::out_of_range& e) {
54855       {
54856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54857       };
54858     } catch (std::exception& e) {
54859       {
54860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54861       };
54862     } catch (...) {
54863       {
54864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54865       };
54866     }
54867   }
54868
54869   //argout typemap for const std::string&
54870
54871 }
54872
54873
54874 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54875   char * jresult ;
54876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54877   std::string *result = 0 ;
54878
54879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54880   {
54881     try {
54882       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
54883     } catch (std::out_of_range& e) {
54884       {
54885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54886       };
54887     } catch (std::exception& e) {
54888       {
54889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54890       };
54891     } catch (...) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54894       };
54895     }
54896   }
54897   jresult = SWIG_csharp_string_callback(result->c_str());
54898   return jresult;
54899 }
54900
54901
54902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54904   Dali::Vector4 *arg2 = 0 ;
54905
54906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54907   arg2 = (Dali::Vector4 *)jarg2;
54908   if (!arg2) {
54909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54910     return ;
54911   }
54912   {
54913     try {
54914       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54915     } catch (std::out_of_range& e) {
54916       {
54917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54918       };
54919     } catch (std::exception& e) {
54920       {
54921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54922       };
54923     } catch (...) {
54924       {
54925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54926       };
54927     }
54928   }
54929 }
54930
54931
54932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54933   void * jresult ;
54934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54935   Dali::Vector4 result;
54936
54937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54938   {
54939     try {
54940       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54941     } catch (std::out_of_range& e) {
54942       {
54943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54944       };
54945     } catch (std::exception& e) {
54946       {
54947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54952       };
54953     }
54954   }
54955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54956   return jresult;
54957 }
54958
54959
54960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54962   Dali::Image arg2 ;
54963   Dali::Image *argp2 ;
54964
54965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54966   argp2 = (Dali::Image *)jarg2;
54967   if (!argp2) {
54968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54969     return ;
54970   }
54971   arg2 = *argp2;
54972   {
54973     try {
54974       (arg1)->SetBackgroundImage(arg2);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (...) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54986       };
54987     }
54988   }
54989 }
54990
54991
54992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54994   Dali::Property::Map *arg2 = 0 ;
54995
54996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54997   arg2 = (Dali::Property::Map *)jarg2;
54998   if (!arg2) {
54999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55000     return ;
55001   }
55002   {
55003     try {
55004       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
55005     } catch (std::out_of_range& e) {
55006       {
55007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (std::exception& e) {
55010       {
55011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (...) {
55014       {
55015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55016       };
55017     }
55018   }
55019 }
55020
55021
55022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
55023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55024
55025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55026   {
55027     try {
55028       (arg1)->ClearBackground();
55029     } catch (std::out_of_range& e) {
55030       {
55031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55032       };
55033     } catch (std::exception& e) {
55034       {
55035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55040       };
55041     }
55042   }
55043 }
55044
55045
55046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55048   Dali::Gesture::Type arg2 ;
55049
55050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55051   arg2 = (Dali::Gesture::Type)jarg2;
55052   {
55053     try {
55054       (arg1)->EnableGestureDetection(arg2);
55055     } catch (std::out_of_range& e) {
55056       {
55057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55058       };
55059     } catch (std::exception& e) {
55060       {
55061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55062       };
55063     } catch (...) {
55064       {
55065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55066       };
55067     }
55068   }
55069 }
55070
55071
55072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55074   Dali::Gesture::Type arg2 ;
55075
55076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55077   arg2 = (Dali::Gesture::Type)jarg2;
55078   {
55079     try {
55080       (arg1)->DisableGestureDetection(arg2);
55081     } catch (std::out_of_range& e) {
55082       {
55083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55084       };
55085     } catch (std::exception& e) {
55086       {
55087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55088       };
55089     } catch (...) {
55090       {
55091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55092       };
55093     }
55094   }
55095 }
55096
55097
55098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55099   void * jresult ;
55100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55101   Dali::PinchGestureDetector result;
55102
55103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55104   {
55105     try {
55106       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55107     } catch (std::out_of_range& e) {
55108       {
55109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55110       };
55111     } catch (std::exception& e) {
55112       {
55113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55114       };
55115     } catch (...) {
55116       {
55117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55118       };
55119     }
55120   }
55121   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55122   return jresult;
55123 }
55124
55125
55126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55127   void * jresult ;
55128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55129   Dali::PanGestureDetector result;
55130
55131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55132   {
55133     try {
55134       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55135     } catch (std::out_of_range& e) {
55136       {
55137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55138       };
55139     } catch (std::exception& e) {
55140       {
55141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55146       };
55147     }
55148   }
55149   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55155   void * jresult ;
55156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55157   Dali::TapGestureDetector result;
55158
55159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55160   {
55161     try {
55162       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55163     } catch (std::out_of_range& e) {
55164       {
55165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (std::exception& e) {
55168       {
55169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55170       };
55171     } catch (...) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55174       };
55175     }
55176   }
55177   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55178   return jresult;
55179 }
55180
55181
55182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55183   void * jresult ;
55184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55185   Dali::LongPressGestureDetector result;
55186
55187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55188   {
55189     try {
55190       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55191     } catch (std::out_of_range& e) {
55192       {
55193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55194       };
55195     } catch (std::exception& e) {
55196       {
55197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55198       };
55199     } catch (...) {
55200       {
55201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55202       };
55203     }
55204   }
55205   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55206   return jresult;
55207 }
55208
55209
55210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55212   bool arg2 ;
55213
55214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55215   arg2 = jarg2 ? true : false;
55216   {
55217     try {
55218       (arg1)->SetKeyboardNavigationSupport(arg2);
55219     } catch (std::out_of_range& e) {
55220       {
55221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55222       };
55223     } catch (std::exception& e) {
55224       {
55225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55226       };
55227     } catch (...) {
55228       {
55229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55230       };
55231     }
55232   }
55233 }
55234
55235
55236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55237   unsigned int jresult ;
55238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55239   bool result;
55240
55241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55242   {
55243     try {
55244       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55245     } catch (std::out_of_range& e) {
55246       {
55247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55248       };
55249     } catch (std::exception& e) {
55250       {
55251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55252       };
55253     } catch (...) {
55254       {
55255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55256       };
55257     }
55258   }
55259   jresult = result;
55260   return jresult;
55261 }
55262
55263
55264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55266
55267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55268   {
55269     try {
55270       (arg1)->SetKeyInputFocus();
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55282       };
55283     }
55284   }
55285 }
55286
55287
55288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55289   unsigned int jresult ;
55290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55291   bool result;
55292
55293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55294   {
55295     try {
55296       result = (bool)(arg1)->HasKeyInputFocus();
55297     } catch (std::out_of_range& e) {
55298       {
55299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55300       };
55301     } catch (std::exception& e) {
55302       {
55303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55304       };
55305     } catch (...) {
55306       {
55307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55308       };
55309     }
55310   }
55311   jresult = result;
55312   return jresult;
55313 }
55314
55315
55316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55317   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55318
55319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55320   {
55321     try {
55322       (arg1)->ClearKeyInputFocus();
55323     } catch (std::out_of_range& e) {
55324       {
55325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55326       };
55327     } catch (std::exception& e) {
55328       {
55329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55330       };
55331     } catch (...) {
55332       {
55333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55334       };
55335     }
55336   }
55337 }
55338
55339
55340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55342   bool arg2 ;
55343
55344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55345   arg2 = jarg2 ? true : false;
55346   {
55347     try {
55348       (arg1)->SetAsKeyboardFocusGroup(arg2);
55349     } catch (std::out_of_range& e) {
55350       {
55351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55352       };
55353     } catch (std::exception& e) {
55354       {
55355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55356       };
55357     } catch (...) {
55358       {
55359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55360       };
55361     }
55362   }
55363 }
55364
55365
55366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55367   unsigned int jresult ;
55368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55369   bool result;
55370
55371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55372   {
55373     try {
55374       result = (bool)(arg1)->IsKeyboardFocusGroup();
55375     } catch (std::out_of_range& e) {
55376       {
55377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55378       };
55379     } catch (std::exception& e) {
55380       {
55381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55382       };
55383     } catch (...) {
55384       {
55385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55386       };
55387     }
55388   }
55389   jresult = result;
55390   return jresult;
55391 }
55392
55393
55394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55396
55397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55398   {
55399     try {
55400       (arg1)->AccessibilityActivate();
55401     } catch (std::out_of_range& e) {
55402       {
55403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55404       };
55405     } catch (std::exception& e) {
55406       {
55407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (...) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55412       };
55413     }
55414   }
55415 }
55416
55417
55418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55420
55421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55422   {
55423     try {
55424       (arg1)->KeyboardEnter();
55425     } catch (std::out_of_range& e) {
55426       {
55427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55428       };
55429     } catch (std::exception& e) {
55430       {
55431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55432       };
55433     } catch (...) {
55434       {
55435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55436       };
55437     }
55438   }
55439 }
55440
55441
55442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55443   void * jresult ;
55444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55445   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55446
55447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55448   {
55449     try {
55450       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55451     } catch (std::out_of_range& e) {
55452       {
55453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (std::exception& e) {
55456       {
55457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55458       };
55459     } catch (...) {
55460       {
55461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55462       };
55463     }
55464   }
55465   jresult = (void *)result;
55466   return jresult;
55467 }
55468
55469
55470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55471   void * jresult ;
55472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55473   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55474
55475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55476   {
55477     try {
55478       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55479     } catch (std::out_of_range& e) {
55480       {
55481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55482       };
55483     } catch (std::exception& e) {
55484       {
55485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55490       };
55491     }
55492   }
55493   jresult = (void *)result;
55494   return jresult;
55495 }
55496
55497
55498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55499   void * jresult ;
55500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55501   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55502
55503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55504   {
55505     try {
55506       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55507     } catch (std::out_of_range& e) {
55508       {
55509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55510       };
55511     } catch (std::exception& e) {
55512       {
55513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55514       };
55515     } catch (...) {
55516       {
55517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55518       };
55519     }
55520   }
55521   jresult = (void *)result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55527   unsigned int jresult ;
55528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55529   Dali::KeyEvent *arg2 = 0 ;
55530   bool result;
55531
55532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55533   arg2 = (Dali::KeyEvent *)jarg2;
55534   if (!arg2) {
55535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55536     return 0;
55537   }
55538   {
55539     try {
55540       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55541     } catch (std::out_of_range& e) {
55542       {
55543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (std::exception& e) {
55546       {
55547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55548       };
55549     } catch (...) {
55550       {
55551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55552       };
55553     }
55554   }
55555   jresult = result;
55556   return jresult;
55557 }
55558
55559
55560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55562   int arg2 ;
55563   SwigDirector_ViewImpl *darg = 0;
55564
55565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55566   arg2 = (int)jarg2;
55567   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55568   {
55569     try {
55570       (darg)->OnStageConnection(arg2);
55571     } catch (std::out_of_range& e) {
55572       {
55573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55574       };
55575     } catch (std::exception& e) {
55576       {
55577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55582       };
55583     }
55584   }
55585 }
55586
55587
55588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55590   int arg2 ;
55591   SwigDirector_ViewImpl *darg = 0;
55592
55593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55594   arg2 = (int)jarg2;
55595   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55596   {
55597     try {
55598       (darg)->OnStageConnectionSwigPublic(arg2);
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55606       };
55607     } catch (...) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55610       };
55611     }
55612   }
55613 }
55614
55615
55616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55618   SwigDirector_ViewImpl *darg = 0;
55619
55620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55621   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55622   {
55623     try {
55624       (darg)->OnStageDisconnection();
55625     } catch (std::out_of_range& e) {
55626       {
55627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55628       };
55629     } catch (std::exception& e) {
55630       {
55631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55632       };
55633     } catch (...) {
55634       {
55635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55636       };
55637     }
55638   }
55639 }
55640
55641
55642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55644   SwigDirector_ViewImpl *darg = 0;
55645
55646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55648   {
55649     try {
55650       (darg)->OnStageDisconnectionSwigPublic();
55651     } catch (std::out_of_range& e) {
55652       {
55653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55654       };
55655     } catch (std::exception& e) {
55656       {
55657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55658       };
55659     } catch (...) {
55660       {
55661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55662       };
55663     }
55664   }
55665 }
55666
55667
55668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55670   Dali::Actor *arg2 = 0 ;
55671   SwigDirector_ViewImpl *darg = 0;
55672
55673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55674   arg2 = (Dali::Actor *)jarg2;
55675   if (!arg2) {
55676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55677     return ;
55678   }
55679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55680   {
55681     try {
55682       (darg)->OnChildAdd(*arg2);
55683     } catch (std::out_of_range& e) {
55684       {
55685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55686       };
55687     } catch (std::exception& e) {
55688       {
55689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55694       };
55695     }
55696   }
55697 }
55698
55699
55700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55702   Dali::Actor *arg2 = 0 ;
55703   SwigDirector_ViewImpl *darg = 0;
55704
55705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55706   arg2 = (Dali::Actor *)jarg2;
55707   if (!arg2) {
55708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55709     return ;
55710   }
55711   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55712   {
55713     try {
55714       (darg)->OnChildAddSwigPublic(*arg2);
55715     } catch (std::out_of_range& e) {
55716       {
55717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55718       };
55719     } catch (std::exception& e) {
55720       {
55721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55722       };
55723     } catch (...) {
55724       {
55725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55726       };
55727     }
55728   }
55729 }
55730
55731
55732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55734   Dali::Actor *arg2 = 0 ;
55735   SwigDirector_ViewImpl *darg = 0;
55736
55737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55738   arg2 = (Dali::Actor *)jarg2;
55739   if (!arg2) {
55740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55741     return ;
55742   }
55743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55744   {
55745     try {
55746       (darg)->OnChildRemove(*arg2);
55747     } catch (std::out_of_range& e) {
55748       {
55749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55750       };
55751     } catch (std::exception& e) {
55752       {
55753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55754       };
55755     } catch (...) {
55756       {
55757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55758       };
55759     }
55760   }
55761 }
55762
55763
55764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55766   Dali::Actor *arg2 = 0 ;
55767   SwigDirector_ViewImpl *darg = 0;
55768
55769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55770   arg2 = (Dali::Actor *)jarg2;
55771   if (!arg2) {
55772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55773     return ;
55774   }
55775   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55776   {
55777     try {
55778       (darg)->OnChildRemoveSwigPublic(*arg2);
55779     } catch (std::out_of_range& e) {
55780       {
55781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55782       };
55783     } catch (std::exception& e) {
55784       {
55785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55786       };
55787     } catch (...) {
55788       {
55789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55790       };
55791     }
55792   }
55793 }
55794
55795
55796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55798   Dali::Property::Index arg2 ;
55799   Dali::Property::Value arg3 ;
55800   Dali::Property::Value *argp3 ;
55801   SwigDirector_ViewImpl *darg = 0;
55802
55803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55804   arg2 = (Dali::Property::Index)jarg2;
55805   argp3 = (Dali::Property::Value *)jarg3;
55806   if (!argp3) {
55807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55808     return ;
55809   }
55810   arg3 = *argp3;
55811   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55812   {
55813     try {
55814       (darg)->OnPropertySet(arg2,arg3);
55815     } catch (std::out_of_range& e) {
55816       {
55817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55818       };
55819     } catch (std::exception& e) {
55820       {
55821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55826       };
55827     }
55828   }
55829 }
55830
55831
55832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55834   Dali::Property::Index arg2 ;
55835   Dali::Property::Value arg3 ;
55836   Dali::Property::Value *argp3 ;
55837   SwigDirector_ViewImpl *darg = 0;
55838
55839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55840   arg2 = (Dali::Property::Index)jarg2;
55841   argp3 = (Dali::Property::Value *)jarg3;
55842   if (!argp3) {
55843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55844     return ;
55845   }
55846   arg3 = *argp3;
55847   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55848   {
55849     try {
55850       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55851     } catch (std::out_of_range& e) {
55852       {
55853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55854       };
55855     } catch (std::exception& e) {
55856       {
55857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55858       };
55859     } catch (...) {
55860       {
55861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55862       };
55863     }
55864   }
55865 }
55866
55867
55868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55870   Dali::Vector3 *arg2 = 0 ;
55871   SwigDirector_ViewImpl *darg = 0;
55872
55873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55874   arg2 = (Dali::Vector3 *)jarg2;
55875   if (!arg2) {
55876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55877     return ;
55878   }
55879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55880   {
55881     try {
55882       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55883     } catch (std::out_of_range& e) {
55884       {
55885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55886       };
55887     } catch (std::exception& e) {
55888       {
55889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55890       };
55891     } catch (...) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55894       };
55895     }
55896   }
55897 }
55898
55899
55900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55902   Dali::Vector3 *arg2 = 0 ;
55903   SwigDirector_ViewImpl *darg = 0;
55904
55905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55906   arg2 = (Dali::Vector3 *)jarg2;
55907   if (!arg2) {
55908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55909     return ;
55910   }
55911   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55912   {
55913     try {
55914       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55915     } catch (std::out_of_range& e) {
55916       {
55917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55918       };
55919     } catch (std::exception& e) {
55920       {
55921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55922       };
55923     } catch (...) {
55924       {
55925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55926       };
55927     }
55928   }
55929 }
55930
55931
55932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55934   Dali::Animation *arg2 = 0 ;
55935   Dali::Vector3 *arg3 = 0 ;
55936   SwigDirector_ViewImpl *darg = 0;
55937
55938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55939   arg2 = (Dali::Animation *)jarg2;
55940   if (!arg2) {
55941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55942     return ;
55943   }
55944   arg3 = (Dali::Vector3 *)jarg3;
55945   if (!arg3) {
55946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55947     return ;
55948   }
55949   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55950   {
55951     try {
55952       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55953     } catch (std::out_of_range& e) {
55954       {
55955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55956       };
55957     } catch (std::exception& e) {
55958       {
55959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55960       };
55961     } catch (...) {
55962       {
55963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55964       };
55965     }
55966   }
55967 }
55968
55969
55970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55972   Dali::Animation *arg2 = 0 ;
55973   Dali::Vector3 *arg3 = 0 ;
55974   SwigDirector_ViewImpl *darg = 0;
55975
55976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55977   arg2 = (Dali::Animation *)jarg2;
55978   if (!arg2) {
55979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55980     return ;
55981   }
55982   arg3 = (Dali::Vector3 *)jarg3;
55983   if (!arg3) {
55984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55985     return ;
55986   }
55987   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55988   {
55989     try {
55990       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55991     } catch (std::out_of_range& e) {
55992       {
55993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55994       };
55995     } catch (std::exception& e) {
55996       {
55997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55998       };
55999     } catch (...) {
56000       {
56001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56002       };
56003     }
56004   }
56005 }
56006
56007
56008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
56009   unsigned int jresult ;
56010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56011   Dali::TouchEvent *arg2 = 0 ;
56012   SwigDirector_ViewImpl *darg = 0;
56013   bool result;
56014
56015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56016   arg2 = (Dali::TouchEvent *)jarg2;
56017   if (!arg2) {
56018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56019     return 0;
56020   }
56021   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56022   {
56023     try {
56024       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
56025     } catch (std::out_of_range& e) {
56026       {
56027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56028       };
56029     } catch (std::exception& e) {
56030       {
56031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56032       };
56033     } catch (...) {
56034       {
56035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56036       };
56037     }
56038   }
56039   jresult = result;
56040   return jresult;
56041 }
56042
56043
56044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56045   unsigned int jresult ;
56046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56047   Dali::TouchEvent *arg2 = 0 ;
56048   SwigDirector_ViewImpl *darg = 0;
56049   bool result;
56050
56051   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56052   arg2 = (Dali::TouchEvent *)jarg2;
56053   if (!arg2) {
56054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56055     return 0;
56056   }
56057   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56058   {
56059     try {
56060       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56061     } catch (std::out_of_range& e) {
56062       {
56063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56064       };
56065     } catch (std::exception& e) {
56066       {
56067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56068       };
56069     } catch (...) {
56070       {
56071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56072       };
56073     }
56074   }
56075   jresult = result;
56076   return jresult;
56077 }
56078
56079
56080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56081   unsigned int jresult ;
56082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56083   Dali::HoverEvent *arg2 = 0 ;
56084   SwigDirector_ViewImpl *darg = 0;
56085   bool result;
56086
56087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56088   arg2 = (Dali::HoverEvent *)jarg2;
56089   if (!arg2) {
56090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56091     return 0;
56092   }
56093   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56094   {
56095     try {
56096       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56097     } catch (std::out_of_range& e) {
56098       {
56099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56100       };
56101     } catch (std::exception& e) {
56102       {
56103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (...) {
56106       {
56107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56108       };
56109     }
56110   }
56111   jresult = result;
56112   return jresult;
56113 }
56114
56115
56116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56117   unsigned int jresult ;
56118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56119   Dali::HoverEvent *arg2 = 0 ;
56120   SwigDirector_ViewImpl *darg = 0;
56121   bool result;
56122
56123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56124   arg2 = (Dali::HoverEvent *)jarg2;
56125   if (!arg2) {
56126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56127     return 0;
56128   }
56129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56130   {
56131     try {
56132       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56133     } catch (std::out_of_range& e) {
56134       {
56135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (std::exception& e) {
56138       {
56139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (...) {
56142       {
56143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56144       };
56145     }
56146   }
56147   jresult = result;
56148   return jresult;
56149 }
56150
56151
56152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56153   unsigned int jresult ;
56154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56155   Dali::KeyEvent *arg2 = 0 ;
56156   SwigDirector_ViewImpl *darg = 0;
56157   bool result;
56158
56159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56160   arg2 = (Dali::KeyEvent *)jarg2;
56161   if (!arg2) {
56162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56163     return 0;
56164   }
56165   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56166   {
56167     try {
56168       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56169     } catch (std::out_of_range& e) {
56170       {
56171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56172       };
56173     } catch (std::exception& e) {
56174       {
56175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56180       };
56181     }
56182   }
56183   jresult = result;
56184   return jresult;
56185 }
56186
56187
56188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56189   unsigned int jresult ;
56190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56191   Dali::KeyEvent *arg2 = 0 ;
56192   SwigDirector_ViewImpl *darg = 0;
56193   bool result;
56194
56195   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56196   arg2 = (Dali::KeyEvent *)jarg2;
56197   if (!arg2) {
56198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56199     return 0;
56200   }
56201   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56202   {
56203     try {
56204       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219   jresult = result;
56220   return jresult;
56221 }
56222
56223
56224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56225   unsigned int jresult ;
56226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56227   Dali::WheelEvent *arg2 = 0 ;
56228   SwigDirector_ViewImpl *darg = 0;
56229   bool result;
56230
56231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56232   arg2 = (Dali::WheelEvent *)jarg2;
56233   if (!arg2) {
56234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56235     return 0;
56236   }
56237   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56238   {
56239     try {
56240       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56241     } catch (std::out_of_range& e) {
56242       {
56243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (std::exception& e) {
56246       {
56247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56252       };
56253     }
56254   }
56255   jresult = result;
56256   return jresult;
56257 }
56258
56259
56260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56261   unsigned int jresult ;
56262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56263   Dali::WheelEvent *arg2 = 0 ;
56264   SwigDirector_ViewImpl *darg = 0;
56265   bool result;
56266
56267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56268   arg2 = (Dali::WheelEvent *)jarg2;
56269   if (!arg2) {
56270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56271     return 0;
56272   }
56273   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56274   {
56275     try {
56276       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56277     } catch (std::out_of_range& e) {
56278       {
56279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56280       };
56281     } catch (std::exception& e) {
56282       {
56283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56284       };
56285     } catch (...) {
56286       {
56287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56288       };
56289     }
56290   }
56291   jresult = result;
56292   return jresult;
56293 }
56294
56295
56296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56298   Dali::Vector2 *arg2 = 0 ;
56299   Dali::RelayoutContainer *arg3 = 0 ;
56300   SwigDirector_ViewImpl *darg = 0;
56301
56302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56303   arg2 = (Dali::Vector2 *)jarg2;
56304   if (!arg2) {
56305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56306     return ;
56307   }
56308   arg3 = (Dali::RelayoutContainer *)jarg3;
56309   if (!arg3) {
56310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56311     return ;
56312   }
56313   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56314   {
56315     try {
56316       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56317     } catch (std::out_of_range& e) {
56318       {
56319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56320       };
56321     } catch (std::exception& e) {
56322       {
56323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56328       };
56329     }
56330   }
56331 }
56332
56333
56334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56336   Dali::Vector2 *arg2 = 0 ;
56337   Dali::RelayoutContainer *arg3 = 0 ;
56338   SwigDirector_ViewImpl *darg = 0;
56339
56340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56341   arg2 = (Dali::Vector2 *)jarg2;
56342   if (!arg2) {
56343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56344     return ;
56345   }
56346   arg3 = (Dali::RelayoutContainer *)jarg3;
56347   if (!arg3) {
56348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56349     return ;
56350   }
56351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56352   {
56353     try {
56354       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56355     } catch (std::out_of_range& e) {
56356       {
56357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56358       };
56359     } catch (std::exception& e) {
56360       {
56361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56362       };
56363     } catch (...) {
56364       {
56365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56366       };
56367     }
56368   }
56369 }
56370
56371
56372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56374   Dali::ResizePolicy::Type arg2 ;
56375   Dali::Dimension::Type arg3 ;
56376   SwigDirector_ViewImpl *darg = 0;
56377
56378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56379   arg2 = (Dali::ResizePolicy::Type)jarg2;
56380   arg3 = (Dali::Dimension::Type)jarg3;
56381   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56382   {
56383     try {
56384       (darg)->OnSetResizePolicy(arg2,arg3);
56385     } catch (std::out_of_range& e) {
56386       {
56387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56388       };
56389     } catch (std::exception& e) {
56390       {
56391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56392       };
56393     } catch (...) {
56394       {
56395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56396       };
56397     }
56398   }
56399 }
56400
56401
56402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56404   Dali::ResizePolicy::Type arg2 ;
56405   Dali::Dimension::Type arg3 ;
56406   SwigDirector_ViewImpl *darg = 0;
56407
56408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56409   arg2 = (Dali::ResizePolicy::Type)jarg2;
56410   arg3 = (Dali::Dimension::Type)jarg3;
56411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56412   {
56413     try {
56414       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56415     } catch (std::out_of_range& e) {
56416       {
56417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56418       };
56419     } catch (std::exception& e) {
56420       {
56421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56422       };
56423     } catch (...) {
56424       {
56425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56426       };
56427     }
56428   }
56429 }
56430
56431
56432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56433   void * jresult ;
56434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56435   SwigDirector_ViewImpl *darg = 0;
56436   Dali::Vector3 result;
56437
56438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56439   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56440   {
56441     try {
56442       result = (darg)->GetNaturalSize();
56443     } catch (std::out_of_range& e) {
56444       {
56445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56446       };
56447     } catch (std::exception& e) {
56448       {
56449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56450       };
56451     } catch (...) {
56452       {
56453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56454       };
56455     }
56456   }
56457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56458   return jresult;
56459 }
56460
56461
56462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56463   void * jresult ;
56464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56465   SwigDirector_ViewImpl *darg = 0;
56466   Dali::Vector3 result;
56467
56468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56469   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56470   {
56471     try {
56472       result = (darg)->GetNaturalSizeSwigPublic();
56473     } catch (std::out_of_range& e) {
56474       {
56475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56476       };
56477     } catch (std::exception& e) {
56478       {
56479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56480       };
56481     } catch (...) {
56482       {
56483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56484       };
56485     }
56486   }
56487   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56488   return jresult;
56489 }
56490
56491
56492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56493   float jresult ;
56494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56495   Dali::Actor *arg2 = 0 ;
56496   Dali::Dimension::Type arg3 ;
56497   SwigDirector_ViewImpl *darg = 0;
56498   float result;
56499
56500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56501   arg2 = (Dali::Actor *)jarg2;
56502   if (!arg2) {
56503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56504     return 0;
56505   }
56506   arg3 = (Dali::Dimension::Type)jarg3;
56507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56508   {
56509     try {
56510       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56511     } catch (std::out_of_range& e) {
56512       {
56513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56514       };
56515     } catch (std::exception& e) {
56516       {
56517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56518       };
56519     } catch (...) {
56520       {
56521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56522       };
56523     }
56524   }
56525   jresult = result;
56526   return jresult;
56527 }
56528
56529
56530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56531   float jresult ;
56532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56533   Dali::Actor *arg2 = 0 ;
56534   Dali::Dimension::Type arg3 ;
56535   SwigDirector_ViewImpl *darg = 0;
56536   float result;
56537
56538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56539   arg2 = (Dali::Actor *)jarg2;
56540   if (!arg2) {
56541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56542     return 0;
56543   }
56544   arg3 = (Dali::Dimension::Type)jarg3;
56545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56546   {
56547     try {
56548       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (...) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56560       };
56561     }
56562   }
56563   jresult = result;
56564   return jresult;
56565 }
56566
56567
56568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56569   float jresult ;
56570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56571   float arg2 ;
56572   SwigDirector_ViewImpl *darg = 0;
56573   float result;
56574
56575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56576   arg2 = (float)jarg2;
56577   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56578   {
56579     try {
56580       result = (float)(darg)->GetHeightForWidth(arg2);
56581     } catch (std::out_of_range& e) {
56582       {
56583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56584       };
56585     } catch (std::exception& e) {
56586       {
56587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (...) {
56590       {
56591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56592       };
56593     }
56594   }
56595   jresult = result;
56596   return jresult;
56597 }
56598
56599
56600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56601   float jresult ;
56602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56603   float arg2 ;
56604   SwigDirector_ViewImpl *darg = 0;
56605   float result;
56606
56607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56608   arg2 = (float)jarg2;
56609   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56610   {
56611     try {
56612       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (...) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56624       };
56625     }
56626   }
56627   jresult = result;
56628   return jresult;
56629 }
56630
56631
56632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56633   float jresult ;
56634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56635   float arg2 ;
56636   SwigDirector_ViewImpl *darg = 0;
56637   float result;
56638
56639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56640   arg2 = (float)jarg2;
56641   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56642   {
56643     try {
56644       result = (float)(darg)->GetWidthForHeight(arg2);
56645     } catch (std::out_of_range& e) {
56646       {
56647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (std::exception& e) {
56650       {
56651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56652       };
56653     } catch (...) {
56654       {
56655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56656       };
56657     }
56658   }
56659   jresult = result;
56660   return jresult;
56661 }
56662
56663
56664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56665   float jresult ;
56666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56667   float arg2 ;
56668   SwigDirector_ViewImpl *darg = 0;
56669   float result;
56670
56671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56672   arg2 = (float)jarg2;
56673   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56674   {
56675     try {
56676       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (...) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56688       };
56689     }
56690   }
56691   jresult = result;
56692   return jresult;
56693 }
56694
56695
56696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56697   unsigned int jresult ;
56698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56699   Dali::Dimension::Type arg2 ;
56700   SwigDirector_ViewImpl *darg = 0;
56701   bool result;
56702
56703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56704   arg2 = (Dali::Dimension::Type)jarg2;
56705   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56706   {
56707     try {
56708       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56716       };
56717     } catch (...) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56720       };
56721     }
56722   }
56723   jresult = result;
56724   return jresult;
56725 }
56726
56727
56728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56729   unsigned int jresult ;
56730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56731   Dali::Dimension::Type arg2 ;
56732   SwigDirector_ViewImpl *darg = 0;
56733   bool result;
56734
56735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56736   arg2 = (Dali::Dimension::Type)jarg2;
56737   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56738   {
56739     try {
56740       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56741     } catch (std::out_of_range& e) {
56742       {
56743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56744       };
56745     } catch (std::exception& e) {
56746       {
56747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56748       };
56749     } catch (...) {
56750       {
56751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56752       };
56753     }
56754   }
56755   jresult = result;
56756   return jresult;
56757 }
56758
56759
56760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56761   unsigned int jresult ;
56762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56763   SwigDirector_ViewImpl *darg = 0;
56764   bool result;
56765
56766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56767   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56768   {
56769     try {
56770       result = (bool)(darg)->RelayoutDependentOnChildren();
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56782       };
56783     }
56784   }
56785   jresult = result;
56786   return jresult;
56787 }
56788
56789
56790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56791   unsigned int jresult ;
56792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56793   SwigDirector_ViewImpl *darg = 0;
56794   bool result;
56795
56796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56797   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56798   {
56799     try {
56800       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56801     } catch (std::out_of_range& e) {
56802       {
56803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56804       };
56805     } catch (std::exception& e) {
56806       {
56807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56808       };
56809     } catch (...) {
56810       {
56811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56812       };
56813     }
56814   }
56815   jresult = result;
56816   return jresult;
56817 }
56818
56819
56820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56822   Dali::Dimension::Type arg2 ;
56823   SwigDirector_ViewImpl *darg = 0;
56824
56825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56826   arg2 = (Dali::Dimension::Type)jarg2;
56827   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56828   {
56829     try {
56830       (darg)->OnCalculateRelayoutSize(arg2);
56831     } catch (std::out_of_range& e) {
56832       {
56833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56834       };
56835     } catch (std::exception& e) {
56836       {
56837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56838       };
56839     } catch (...) {
56840       {
56841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56842       };
56843     }
56844   }
56845 }
56846
56847
56848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56850   Dali::Dimension::Type arg2 ;
56851   SwigDirector_ViewImpl *darg = 0;
56852
56853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56854   arg2 = (Dali::Dimension::Type)jarg2;
56855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56856   {
56857     try {
56858       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56859     } catch (std::out_of_range& e) {
56860       {
56861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56862       };
56863     } catch (std::exception& e) {
56864       {
56865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56866       };
56867     } catch (...) {
56868       {
56869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56870       };
56871     }
56872   }
56873 }
56874
56875
56876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56878   float arg2 ;
56879   Dali::Dimension::Type arg3 ;
56880   SwigDirector_ViewImpl *darg = 0;
56881
56882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56883   arg2 = (float)jarg2;
56884   arg3 = (Dali::Dimension::Type)jarg3;
56885   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56886   {
56887     try {
56888       (darg)->OnLayoutNegotiated(arg2,arg3);
56889     } catch (std::out_of_range& e) {
56890       {
56891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56892       };
56893     } catch (std::exception& e) {
56894       {
56895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56896       };
56897     } catch (...) {
56898       {
56899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56900       };
56901     }
56902   }
56903 }
56904
56905
56906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56908   float arg2 ;
56909   Dali::Dimension::Type arg3 ;
56910   SwigDirector_ViewImpl *darg = 0;
56911
56912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56913   arg2 = (float)jarg2;
56914   arg3 = (Dali::Dimension::Type)jarg3;
56915   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56916   {
56917     try {
56918       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
56919     } catch (std::out_of_range& e) {
56920       {
56921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56922       };
56923     } catch (std::exception& e) {
56924       {
56925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56926       };
56927     } catch (...) {
56928       {
56929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56930       };
56931     }
56932   }
56933 }
56934
56935
56936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
56937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56938
56939   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56940   {
56941     try {
56942       (arg1)->OnInitialize();
56943     } catch (std::out_of_range& e) {
56944       {
56945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56946       };
56947     } catch (std::exception& e) {
56948       {
56949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56950       };
56951     } catch (...) {
56952       {
56953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56954       };
56955     }
56956   }
56957 }
56958
56959
56960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56962
56963   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56964   {
56965     try {
56966       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56967     } catch (std::out_of_range& e) {
56968       {
56969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56970       };
56971     } catch (std::exception& e) {
56972       {
56973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56974       };
56975     } catch (...) {
56976       {
56977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56978       };
56979     }
56980   }
56981 }
56982
56983
56984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56986   Dali::Actor *arg2 = 0 ;
56987
56988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56989   arg2 = (Dali::Actor *)jarg2;
56990   if (!arg2) {
56991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56992     return ;
56993   }
56994   {
56995     try {
56996       (arg1)->OnControlChildAdd(*arg2);
56997     } catch (std::out_of_range& e) {
56998       {
56999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57000       };
57001     } catch (std::exception& e) {
57002       {
57003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57004       };
57005     } catch (...) {
57006       {
57007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57008       };
57009     }
57010   }
57011 }
57012
57013
57014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57016   Dali::Actor *arg2 = 0 ;
57017
57018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57019   arg2 = (Dali::Actor *)jarg2;
57020   if (!arg2) {
57021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57022     return ;
57023   }
57024   {
57025     try {
57026       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57038       };
57039     }
57040   }
57041 }
57042
57043
57044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57046   Dali::Actor *arg2 = 0 ;
57047
57048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57049   arg2 = (Dali::Actor *)jarg2;
57050   if (!arg2) {
57051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57052     return ;
57053   }
57054   {
57055     try {
57056       (arg1)->OnControlChildRemove(*arg2);
57057     } catch (std::out_of_range& e) {
57058       {
57059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57060       };
57061     } catch (std::exception& e) {
57062       {
57063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57064       };
57065     } catch (...) {
57066       {
57067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57068       };
57069     }
57070   }
57071 }
57072
57073
57074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57076   Dali::Actor *arg2 = 0 ;
57077
57078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57079   arg2 = (Dali::Actor *)jarg2;
57080   if (!arg2) {
57081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57082     return ;
57083   }
57084   {
57085     try {
57086       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57087     } catch (std::out_of_range& e) {
57088       {
57089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57090       };
57091     } catch (std::exception& e) {
57092       {
57093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57094       };
57095     } catch (...) {
57096       {
57097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57098       };
57099     }
57100   }
57101 }
57102
57103
57104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57106   Dali::Toolkit::StyleManager arg2 ;
57107   Dali::StyleChange::Type arg3 ;
57108   Dali::Toolkit::StyleManager *argp2 ;
57109
57110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57111   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57112   if (!argp2) {
57113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57114     return ;
57115   }
57116   arg2 = *argp2;
57117   arg3 = (Dali::StyleChange::Type)jarg3;
57118   {
57119     try {
57120       (arg1)->OnStyleChange(arg2,arg3);
57121     } catch (std::out_of_range& e) {
57122       {
57123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57124       };
57125     } catch (std::exception& e) {
57126       {
57127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57128       };
57129     } catch (...) {
57130       {
57131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57132       };
57133     }
57134   }
57135 }
57136
57137
57138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57140   Dali::Toolkit::StyleManager arg2 ;
57141   Dali::StyleChange::Type arg3 ;
57142   Dali::Toolkit::StyleManager *argp2 ;
57143
57144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57145   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57146   if (!argp2) {
57147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57148     return ;
57149   }
57150   arg2 = *argp2;
57151   arg3 = (Dali::StyleChange::Type)jarg3;
57152   {
57153     try {
57154       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57155     } catch (std::out_of_range& e) {
57156       {
57157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57158       };
57159     } catch (std::exception& e) {
57160       {
57161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57162       };
57163     } catch (...) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57166       };
57167     }
57168   }
57169 }
57170
57171
57172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57173   unsigned int jresult ;
57174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57175   bool result;
57176
57177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57178   {
57179     try {
57180       result = (bool)(arg1)->OnAccessibilityActivated();
57181     } catch (std::out_of_range& e) {
57182       {
57183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57184       };
57185     } catch (std::exception& e) {
57186       {
57187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57188       };
57189     } catch (...) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57192       };
57193     }
57194   }
57195   jresult = result;
57196   return jresult;
57197 }
57198
57199
57200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57201   unsigned int jresult ;
57202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57203   bool result;
57204
57205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57206   {
57207     try {
57208       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57209     } catch (std::out_of_range& e) {
57210       {
57211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (std::exception& e) {
57214       {
57215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223   jresult = result;
57224   return jresult;
57225 }
57226
57227
57228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57229   unsigned int jresult ;
57230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57231   Dali::PanGesture arg2 ;
57232   Dali::PanGesture *argp2 ;
57233   bool result;
57234
57235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57236   argp2 = (Dali::PanGesture *)jarg2;
57237   if (!argp2) {
57238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57239     return 0;
57240   }
57241   arg2 = *argp2;
57242   {
57243     try {
57244       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57245     } catch (std::out_of_range& e) {
57246       {
57247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57248       };
57249     } catch (std::exception& e) {
57250       {
57251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57252       };
57253     } catch (...) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57256       };
57257     }
57258   }
57259   jresult = result;
57260   return jresult;
57261 }
57262
57263
57264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57265   unsigned int jresult ;
57266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57267   Dali::PanGesture arg2 ;
57268   Dali::PanGesture *argp2 ;
57269   bool result;
57270
57271   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57272   argp2 = (Dali::PanGesture *)jarg2;
57273   if (!argp2) {
57274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57275     return 0;
57276   }
57277   arg2 = *argp2;
57278   {
57279     try {
57280       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57281     } catch (std::out_of_range& e) {
57282       {
57283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57284       };
57285     } catch (std::exception& e) {
57286       {
57287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (...) {
57290       {
57291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57292       };
57293     }
57294   }
57295   jresult = result;
57296   return jresult;
57297 }
57298
57299
57300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57301   unsigned int jresult ;
57302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57303   Dali::TouchEvent *arg2 = 0 ;
57304   bool result;
57305
57306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57307   arg2 = (Dali::TouchEvent *)jarg2;
57308   if (!arg2) {
57309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57310     return 0;
57311   }
57312   {
57313     try {
57314       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57315     } catch (std::out_of_range& e) {
57316       {
57317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (std::exception& e) {
57320       {
57321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57326       };
57327     }
57328   }
57329   jresult = result;
57330   return jresult;
57331 }
57332
57333
57334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57335   unsigned int jresult ;
57336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57337   Dali::TouchEvent *arg2 = 0 ;
57338   bool result;
57339
57340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57341   arg2 = (Dali::TouchEvent *)jarg2;
57342   if (!arg2) {
57343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57344     return 0;
57345   }
57346   {
57347     try {
57348       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57349     } catch (std::out_of_range& e) {
57350       {
57351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57352       };
57353     } catch (std::exception& e) {
57354       {
57355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57356       };
57357     } catch (...) {
57358       {
57359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57360       };
57361     }
57362   }
57363   jresult = result;
57364   return jresult;
57365 }
57366
57367
57368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57369   unsigned int jresult ;
57370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57371   bool arg2 ;
57372   bool result;
57373
57374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57375   arg2 = jarg2 ? true : false;
57376   {
57377     try {
57378       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57379     } catch (std::out_of_range& e) {
57380       {
57381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57382       };
57383     } catch (std::exception& e) {
57384       {
57385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57386       };
57387     } catch (...) {
57388       {
57389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57390       };
57391     }
57392   }
57393   jresult = result;
57394   return jresult;
57395 }
57396
57397
57398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57399   unsigned int jresult ;
57400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57401   bool arg2 ;
57402   bool result;
57403
57404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57405   arg2 = jarg2 ? true : false;
57406   {
57407     try {
57408       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57409     } catch (std::out_of_range& e) {
57410       {
57411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57412       };
57413     } catch (std::exception& e) {
57414       {
57415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57416       };
57417     } catch (...) {
57418       {
57419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57420       };
57421     }
57422   }
57423   jresult = result;
57424   return jresult;
57425 }
57426
57427
57428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57429   unsigned int jresult ;
57430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57431   bool result;
57432
57433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57434   {
57435     try {
57436       result = (bool)(arg1)->OnAccessibilityZoom();
57437     } catch (std::out_of_range& e) {
57438       {
57439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57440       };
57441     } catch (std::exception& e) {
57442       {
57443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57444       };
57445     } catch (...) {
57446       {
57447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57448       };
57449     }
57450   }
57451   jresult = result;
57452   return jresult;
57453 }
57454
57455
57456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57457   unsigned int jresult ;
57458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57459   bool result;
57460
57461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57462   {
57463     try {
57464       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57465     } catch (std::out_of_range& e) {
57466       {
57467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57468       };
57469     } catch (std::exception& e) {
57470       {
57471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57472       };
57473     } catch (...) {
57474       {
57475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57476       };
57477     }
57478   }
57479   jresult = result;
57480   return jresult;
57481 }
57482
57483
57484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57486
57487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57488   {
57489     try {
57490       (arg1)->OnKeyInputFocusGained();
57491     } catch (std::out_of_range& e) {
57492       {
57493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57494       };
57495     } catch (std::exception& e) {
57496       {
57497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57498       };
57499     } catch (...) {
57500       {
57501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57502       };
57503     }
57504   }
57505 }
57506
57507
57508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57510
57511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57512   {
57513     try {
57514       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57515     } catch (std::out_of_range& e) {
57516       {
57517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57518       };
57519     } catch (std::exception& e) {
57520       {
57521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57522       };
57523     } catch (...) {
57524       {
57525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57526       };
57527     }
57528   }
57529 }
57530
57531
57532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57534
57535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57536   {
57537     try {
57538       (arg1)->OnKeyInputFocusLost();
57539     } catch (std::out_of_range& e) {
57540       {
57541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57542       };
57543     } catch (std::exception& e) {
57544       {
57545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57546       };
57547     } catch (...) {
57548       {
57549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57550       };
57551     }
57552   }
57553 }
57554
57555
57556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57558
57559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57560   {
57561     try {
57562       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57563     } catch (std::out_of_range& e) {
57564       {
57565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57566       };
57567     } catch (std::exception& e) {
57568       {
57569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57570       };
57571     } catch (...) {
57572       {
57573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57574       };
57575     }
57576   }
57577 }
57578
57579
57580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57581   void * jresult ;
57582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57583   Dali::Actor arg2 ;
57584   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57585   bool arg4 ;
57586   Dali::Actor *argp2 ;
57587   Dali::Actor result;
57588
57589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57590   argp2 = (Dali::Actor *)jarg2;
57591   if (!argp2) {
57592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57593     return 0;
57594   }
57595   arg2 = *argp2;
57596   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57597   arg4 = jarg4 ? true : false;
57598   {
57599     try {
57600       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57601     } catch (std::out_of_range& e) {
57602       {
57603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (std::exception& e) {
57606       {
57607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (...) {
57610       {
57611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57612       };
57613     }
57614   }
57615   jresult = new Dali::Actor((const Dali::Actor &)result);
57616   return jresult;
57617 }
57618
57619
57620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57621   void * jresult ;
57622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57623   Dali::Actor arg2 ;
57624   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57625   bool arg4 ;
57626   Dali::Actor *argp2 ;
57627   Dali::Actor result;
57628
57629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57630   argp2 = (Dali::Actor *)jarg2;
57631   if (!argp2) {
57632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57633     return 0;
57634   }
57635   arg2 = *argp2;
57636   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57637   arg4 = jarg4 ? true : false;
57638   {
57639     try {
57640       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57641     } catch (std::out_of_range& e) {
57642       {
57643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57644       };
57645     } catch (std::exception& e) {
57646       {
57647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57648       };
57649     } catch (...) {
57650       {
57651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57652       };
57653     }
57654   }
57655   jresult = new Dali::Actor((const Dali::Actor &)result);
57656   return jresult;
57657 }
57658
57659
57660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57662   Dali::Actor arg2 ;
57663   Dali::Actor *argp2 ;
57664
57665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57666   argp2 = (Dali::Actor *)jarg2;
57667   if (!argp2) {
57668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57669     return ;
57670   }
57671   arg2 = *argp2;
57672   {
57673     try {
57674       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57675     } catch (std::out_of_range& e) {
57676       {
57677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57678       };
57679     } catch (std::exception& e) {
57680       {
57681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57682       };
57683     } catch (...) {
57684       {
57685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57686       };
57687     }
57688   }
57689 }
57690
57691
57692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57694   Dali::Actor arg2 ;
57695   Dali::Actor *argp2 ;
57696
57697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57698   argp2 = (Dali::Actor *)jarg2;
57699   if (!argp2) {
57700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57701     return ;
57702   }
57703   arg2 = *argp2;
57704   {
57705     try {
57706       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57707     } catch (std::out_of_range& e) {
57708       {
57709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (std::exception& e) {
57712       {
57713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57714       };
57715     } catch (...) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57718       };
57719     }
57720   }
57721 }
57722
57723
57724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57725   unsigned int jresult ;
57726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57727   bool result;
57728
57729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57730   {
57731     try {
57732       result = (bool)(arg1)->OnKeyboardEnter();
57733     } catch (std::out_of_range& e) {
57734       {
57735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57736       };
57737     } catch (std::exception& e) {
57738       {
57739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57740       };
57741     } catch (...) {
57742       {
57743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57744       };
57745     }
57746   }
57747   jresult = result;
57748   return jresult;
57749 }
57750
57751
57752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57753   unsigned int jresult ;
57754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57755   bool result;
57756
57757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57758   {
57759     try {
57760       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57761     } catch (std::out_of_range& e) {
57762       {
57763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (std::exception& e) {
57766       {
57767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57768       };
57769     } catch (...) {
57770       {
57771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57772       };
57773     }
57774   }
57775   jresult = result;
57776   return jresult;
57777 }
57778
57779
57780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57782   Dali::PinchGesture *arg2 = 0 ;
57783
57784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57785   arg2 = (Dali::PinchGesture *)jarg2;
57786   if (!arg2) {
57787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57788     return ;
57789   }
57790   {
57791     try {
57792       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57793     } catch (std::out_of_range& e) {
57794       {
57795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57796       };
57797     } catch (std::exception& e) {
57798       {
57799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57800       };
57801     } catch (...) {
57802       {
57803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57804       };
57805     }
57806   }
57807 }
57808
57809
57810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57812   Dali::PinchGesture *arg2 = 0 ;
57813
57814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57815   arg2 = (Dali::PinchGesture *)jarg2;
57816   if (!arg2) {
57817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57818     return ;
57819   }
57820   {
57821     try {
57822       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57823     } catch (std::out_of_range& e) {
57824       {
57825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57826       };
57827     } catch (std::exception& e) {
57828       {
57829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57830       };
57831     } catch (...) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57834       };
57835     }
57836   }
57837 }
57838
57839
57840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57842   Dali::PanGesture *arg2 = 0 ;
57843
57844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57845   arg2 = (Dali::PanGesture *)jarg2;
57846   if (!arg2) {
57847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57848     return ;
57849   }
57850   {
57851     try {
57852       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
57853     } catch (std::out_of_range& e) {
57854       {
57855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57856       };
57857     } catch (std::exception& e) {
57858       {
57859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57860       };
57861     } catch (...) {
57862       {
57863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57864       };
57865     }
57866   }
57867 }
57868
57869
57870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57872   Dali::PanGesture *arg2 = 0 ;
57873
57874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57875   arg2 = (Dali::PanGesture *)jarg2;
57876   if (!arg2) {
57877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57878     return ;
57879   }
57880   {
57881     try {
57882       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57883     } catch (std::out_of_range& e) {
57884       {
57885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57886       };
57887     } catch (std::exception& e) {
57888       {
57889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57890       };
57891     } catch (...) {
57892       {
57893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57894       };
57895     }
57896   }
57897 }
57898
57899
57900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57902   Dali::TapGesture *arg2 = 0 ;
57903
57904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57905   arg2 = (Dali::TapGesture *)jarg2;
57906   if (!arg2) {
57907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57908     return ;
57909   }
57910   {
57911     try {
57912       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57924       };
57925     }
57926   }
57927 }
57928
57929
57930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57932   Dali::TapGesture *arg2 = 0 ;
57933
57934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57935   arg2 = (Dali::TapGesture *)jarg2;
57936   if (!arg2) {
57937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57938     return ;
57939   }
57940   {
57941     try {
57942       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57943     } catch (std::out_of_range& e) {
57944       {
57945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57946       };
57947     } catch (std::exception& e) {
57948       {
57949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57950       };
57951     } catch (...) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57954       };
57955     }
57956   }
57957 }
57958
57959
57960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57962   Dali::LongPressGesture *arg2 = 0 ;
57963
57964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57965   arg2 = (Dali::LongPressGesture *)jarg2;
57966   if (!arg2) {
57967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57968     return ;
57969   }
57970   {
57971     try {
57972       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57973     } catch (std::out_of_range& e) {
57974       {
57975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57976       };
57977     } catch (std::exception& e) {
57978       {
57979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57980       };
57981     } catch (...) {
57982       {
57983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57984       };
57985     }
57986   }
57987 }
57988
57989
57990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57992   Dali::LongPressGesture *arg2 = 0 ;
57993
57994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57995   arg2 = (Dali::LongPressGesture *)jarg2;
57996   if (!arg2) {
57997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57998     return ;
57999   }
58000   {
58001     try {
58002       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
58003     } catch (std::out_of_range& e) {
58004       {
58005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58006       };
58007     } catch (std::exception& e) {
58008       {
58009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58010       };
58011     } catch (...) {
58012       {
58013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58014       };
58015     }
58016   }
58017 }
58018
58019
58020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58022   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58023   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58024
58025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58026   arg2 = (Dali::SlotObserver *)jarg2;
58027   arg3 = (Dali::CallbackBase *)jarg3;
58028   {
58029     try {
58030       (arg1)->SignalConnected(arg2,arg3);
58031     } catch (std::out_of_range& e) {
58032       {
58033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58034       };
58035     } catch (std::exception& e) {
58036       {
58037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58038       };
58039     } catch (...) {
58040       {
58041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58042       };
58043     }
58044   }
58045 }
58046
58047
58048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58050   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58051   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58052
58053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58054   arg2 = (Dali::SlotObserver *)jarg2;
58055   arg3 = (Dali::CallbackBase *)jarg3;
58056   {
58057     try {
58058       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58059     } catch (std::out_of_range& e) {
58060       {
58061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58062       };
58063     } catch (std::exception& e) {
58064       {
58065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58066       };
58067     } catch (...) {
58068       {
58069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58070       };
58071     }
58072   }
58073 }
58074
58075
58076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58078   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58079   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58080
58081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58082   arg2 = (Dali::SlotObserver *)jarg2;
58083   arg3 = (Dali::CallbackBase *)jarg3;
58084   {
58085     try {
58086       (arg1)->SignalDisconnected(arg2,arg3);
58087     } catch (std::out_of_range& e) {
58088       {
58089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58090       };
58091     } catch (std::exception& e) {
58092       {
58093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58094       };
58095     } catch (...) {
58096       {
58097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58098       };
58099     }
58100   }
58101 }
58102
58103
58104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58106   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58107   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58108
58109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58110   arg2 = (Dali::SlotObserver *)jarg2;
58111   arg3 = (Dali::CallbackBase *)jarg3;
58112   {
58113     try {
58114       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58115     } catch (std::out_of_range& e) {
58116       {
58117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58118       };
58119     } catch (std::exception& e) {
58120       {
58121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58122       };
58123     } catch (...) {
58124       {
58125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58126       };
58127     }
58128   }
58129 }
58130
58131
58132 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) {
58133   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58134   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58135   if (director) {
58136     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);
58137   }
58138 }
58139
58140
58141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58142   void * jresult ;
58143   Dali::Toolkit::Control *arg1 = 0 ;
58144   Dali::Toolkit::Internal::Control *result = 0 ;
58145
58146   arg1 = (Dali::Toolkit::Control *)jarg1;
58147   if (!arg1) {
58148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58149     return 0;
58150   }
58151   {
58152     try {
58153       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58154     } catch (std::out_of_range& e) {
58155       {
58156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58157       };
58158     } catch (std::exception& e) {
58159       {
58160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58161       };
58162     } catch (...) {
58163       {
58164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58165       };
58166     }
58167   }
58168   jresult = (void *)result;
58169   return jresult;
58170 }
58171
58172
58173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58174   int jresult ;
58175   int result;
58176
58177   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58178   jresult = (int)result;
58179   return jresult;
58180 }
58181
58182
58183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58184   int jresult ;
58185   int result;
58186
58187   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58188   jresult = (int)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58194   int jresult ;
58195   int result;
58196
58197   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58198   jresult = (int)result;
58199   return jresult;
58200 }
58201
58202
58203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58204   int jresult ;
58205   int result;
58206
58207   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58208   jresult = (int)result;
58209   return jresult;
58210 }
58211
58212
58213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58214   int jresult ;
58215   int result;
58216
58217   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58218   jresult = (int)result;
58219   return jresult;
58220 }
58221
58222
58223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58224   void * jresult ;
58225   Dali::Toolkit::Control::Property *result = 0 ;
58226
58227   {
58228     try {
58229       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58230     } catch (std::out_of_range& e) {
58231       {
58232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58233       };
58234     } catch (std::exception& e) {
58235       {
58236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58237       };
58238     } catch (...) {
58239       {
58240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58241       };
58242     }
58243   }
58244   jresult = (void *)result;
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58250   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58251
58252   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58253   {
58254     try {
58255       delete arg1;
58256     } catch (std::out_of_range& e) {
58257       {
58258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58259       };
58260     } catch (std::exception& e) {
58261       {
58262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58263       };
58264     } catch (...) {
58265       {
58266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58267       };
58268     }
58269   }
58270 }
58271
58272
58273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58274   void * jresult ;
58275   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58276
58277   {
58278     try {
58279       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58280     } catch (std::out_of_range& e) {
58281       {
58282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58283       };
58284     } catch (std::exception& e) {
58285       {
58286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58287       };
58288     } catch (...) {
58289       {
58290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58291       };
58292     }
58293   }
58294   jresult = (void *)result;
58295   return jresult;
58296 }
58297
58298
58299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58300   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58301
58302   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58303   {
58304     try {
58305       delete arg1;
58306     } catch (std::out_of_range& e) {
58307       {
58308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58309       };
58310     } catch (std::exception& e) {
58311       {
58312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58313       };
58314     } catch (...) {
58315       {
58316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58317       };
58318     }
58319   }
58320 }
58321
58322
58323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58324   void * jresult ;
58325   Dali::Toolkit::Control result;
58326
58327   {
58328     try {
58329       result = Dali::Toolkit::Control::New();
58330     } catch (std::out_of_range& e) {
58331       {
58332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (std::exception& e) {
58335       {
58336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58337       };
58338     } catch (...) {
58339       {
58340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58341       };
58342     }
58343   }
58344   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58345   return jresult;
58346 }
58347
58348
58349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58350   void * jresult ;
58351   Dali::Toolkit::Control *result = 0 ;
58352
58353   {
58354     try {
58355       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (...) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58367       };
58368     }
58369   }
58370   jresult = (void *)result;
58371   return jresult;
58372 }
58373
58374
58375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58376   void * jresult ;
58377   Dali::Toolkit::Control *arg1 = 0 ;
58378   Dali::Toolkit::Control *result = 0 ;
58379
58380   arg1 = (Dali::Toolkit::Control *)jarg1;
58381   if (!arg1) {
58382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58383     return 0;
58384   }
58385   {
58386     try {
58387       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58388     } catch (std::out_of_range& e) {
58389       {
58390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58391       };
58392     } catch (std::exception& e) {
58393       {
58394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58395       };
58396     } catch (...) {
58397       {
58398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58399       };
58400     }
58401   }
58402   jresult = (void *)result;
58403   return jresult;
58404 }
58405
58406
58407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58408   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58409
58410   arg1 = (Dali::Toolkit::Control *)jarg1;
58411   {
58412     try {
58413       delete arg1;
58414     } catch (std::out_of_range& e) {
58415       {
58416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58417       };
58418     } catch (std::exception& e) {
58419       {
58420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58421       };
58422     } catch (...) {
58423       {
58424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58425       };
58426     }
58427   }
58428 }
58429
58430
58431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58432   void * jresult ;
58433   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58434   Dali::Toolkit::Control *arg2 = 0 ;
58435   Dali::Toolkit::Control *result = 0 ;
58436
58437   arg1 = (Dali::Toolkit::Control *)jarg1;
58438   arg2 = (Dali::Toolkit::Control *)jarg2;
58439   if (!arg2) {
58440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58441     return 0;
58442   }
58443   {
58444     try {
58445       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58446     } catch (std::out_of_range& e) {
58447       {
58448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58449       };
58450     } catch (std::exception& e) {
58451       {
58452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58453       };
58454     } catch (...) {
58455       {
58456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58457       };
58458     }
58459   }
58460   jresult = (void *)result;
58461   return jresult;
58462 }
58463
58464
58465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58466   void * jresult ;
58467   Dali::BaseHandle arg1 ;
58468   Dali::BaseHandle *argp1 ;
58469   Dali::Toolkit::Control result;
58470
58471   argp1 = (Dali::BaseHandle *)jarg1;
58472   if (!argp1) {
58473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58474     return 0;
58475   }
58476   arg1 = *argp1;
58477   {
58478     try {
58479       result = Dali::Toolkit::Control::DownCast(arg1);
58480     } catch (std::out_of_range& e) {
58481       {
58482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58483       };
58484     } catch (std::exception& e) {
58485       {
58486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58487       };
58488     } catch (...) {
58489       {
58490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58491       };
58492     }
58493   }
58494   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58495   return jresult;
58496 }
58497
58498
58499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58500   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58501
58502   arg1 = (Dali::Toolkit::Control *)jarg1;
58503   {
58504     try {
58505       (arg1)->SetKeyInputFocus();
58506     } catch (std::out_of_range& e) {
58507       {
58508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58509       };
58510     } catch (std::exception& e) {
58511       {
58512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58513       };
58514     } catch (...) {
58515       {
58516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58517       };
58518     }
58519   }
58520 }
58521
58522
58523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58524   unsigned int jresult ;
58525   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58526   bool result;
58527
58528   arg1 = (Dali::Toolkit::Control *)jarg1;
58529   {
58530     try {
58531       result = (bool)(arg1)->HasKeyInputFocus();
58532     } catch (std::out_of_range& e) {
58533       {
58534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58535       };
58536     } catch (std::exception& e) {
58537       {
58538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58539       };
58540     } catch (...) {
58541       {
58542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58543       };
58544     }
58545   }
58546   jresult = result;
58547   return jresult;
58548 }
58549
58550
58551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58552   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58553
58554   arg1 = (Dali::Toolkit::Control *)jarg1;
58555   {
58556     try {
58557       (arg1)->ClearKeyInputFocus();
58558     } catch (std::out_of_range& e) {
58559       {
58560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58561       };
58562     } catch (std::exception& e) {
58563       {
58564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58565       };
58566     } catch (...) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58569       };
58570     }
58571   }
58572 }
58573
58574
58575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58576   void * jresult ;
58577   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58578   Dali::PinchGestureDetector result;
58579
58580   arg1 = (Dali::Toolkit::Control *)jarg1;
58581   {
58582     try {
58583       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58584     } catch (std::out_of_range& e) {
58585       {
58586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58587       };
58588     } catch (std::exception& e) {
58589       {
58590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58591       };
58592     } catch (...) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58595       };
58596     }
58597   }
58598   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58599   return jresult;
58600 }
58601
58602
58603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58604   void * jresult ;
58605   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58606   Dali::PanGestureDetector result;
58607
58608   arg1 = (Dali::Toolkit::Control *)jarg1;
58609   {
58610     try {
58611       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58612     } catch (std::out_of_range& e) {
58613       {
58614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58615       };
58616     } catch (std::exception& e) {
58617       {
58618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58619       };
58620     } catch (...) {
58621       {
58622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58623       };
58624     }
58625   }
58626   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58627   return jresult;
58628 }
58629
58630
58631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58632   void * jresult ;
58633   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58634   Dali::TapGestureDetector result;
58635
58636   arg1 = (Dali::Toolkit::Control *)jarg1;
58637   {
58638     try {
58639       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58640     } catch (std::out_of_range& e) {
58641       {
58642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58643       };
58644     } catch (std::exception& e) {
58645       {
58646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58647       };
58648     } catch (...) {
58649       {
58650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58651       };
58652     }
58653   }
58654   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58655   return jresult;
58656 }
58657
58658
58659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58660   void * jresult ;
58661   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58662   Dali::LongPressGestureDetector result;
58663
58664   arg1 = (Dali::Toolkit::Control *)jarg1;
58665   {
58666     try {
58667       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58668     } catch (std::out_of_range& e) {
58669       {
58670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58671       };
58672     } catch (std::exception& e) {
58673       {
58674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58675       };
58676     } catch (...) {
58677       {
58678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58679       };
58680     }
58681   }
58682   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58683   return jresult;
58684 }
58685
58686
58687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58688   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58689   std::string *arg2 = 0 ;
58690
58691   arg1 = (Dali::Toolkit::Control *)jarg1;
58692   if (!jarg2) {
58693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58694     return ;
58695   }
58696   std::string arg2_str(jarg2);
58697   arg2 = &arg2_str;
58698   {
58699     try {
58700       (arg1)->SetStyleName((std::string const &)*arg2);
58701     } catch (std::out_of_range& e) {
58702       {
58703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58704       };
58705     } catch (std::exception& e) {
58706       {
58707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58708       };
58709     } catch (...) {
58710       {
58711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58712       };
58713     }
58714   }
58715
58716   //argout typemap for const std::string&
58717
58718 }
58719
58720
58721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58722   char * jresult ;
58723   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58724   std::string *result = 0 ;
58725
58726   arg1 = (Dali::Toolkit::Control *)jarg1;
58727   {
58728     try {
58729       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58730     } catch (std::out_of_range& e) {
58731       {
58732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58733       };
58734     } catch (std::exception& e) {
58735       {
58736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58737       };
58738     } catch (...) {
58739       {
58740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58741       };
58742     }
58743   }
58744   jresult = SWIG_csharp_string_callback(result->c_str());
58745   return jresult;
58746 }
58747
58748
58749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58750   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58751   Dali::Vector4 *arg2 = 0 ;
58752
58753   arg1 = (Dali::Toolkit::Control *)jarg1;
58754   arg2 = (Dali::Vector4 *)jarg2;
58755   if (!arg2) {
58756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58757     return ;
58758   }
58759   {
58760     try {
58761       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58762     } catch (std::out_of_range& e) {
58763       {
58764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58765       };
58766     } catch (std::exception& e) {
58767       {
58768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58773       };
58774     }
58775   }
58776 }
58777
58778
58779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58780   void * jresult ;
58781   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58782   Dali::Vector4 result;
58783
58784   arg1 = (Dali::Toolkit::Control *)jarg1;
58785   {
58786     try {
58787       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58788     } catch (std::out_of_range& e) {
58789       {
58790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (std::exception& e) {
58793       {
58794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58795       };
58796     } catch (...) {
58797       {
58798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58799       };
58800     }
58801   }
58802   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58808   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58809   Dali::Image arg2 ;
58810   Dali::Image *argp2 ;
58811
58812   arg1 = (Dali::Toolkit::Control *)jarg1;
58813   argp2 = (Dali::Image *)jarg2;
58814   if (!argp2) {
58815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58816     return ;
58817   }
58818   arg2 = *argp2;
58819   {
58820     try {
58821       (arg1)->SetBackgroundImage(arg2);
58822     } catch (std::out_of_range& e) {
58823       {
58824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58825       };
58826     } catch (std::exception& e) {
58827       {
58828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58829       };
58830     } catch (...) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58833       };
58834     }
58835   }
58836 }
58837
58838
58839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58840   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58841
58842   arg1 = (Dali::Toolkit::Control *)jarg1;
58843   {
58844     try {
58845       (arg1)->ClearBackground();
58846     } catch (std::out_of_range& e) {
58847       {
58848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58849       };
58850     } catch (std::exception& e) {
58851       {
58852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58853       };
58854     } catch (...) {
58855       {
58856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58857       };
58858     }
58859   }
58860 }
58861
58862
58863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58864   void * jresult ;
58865   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58866   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58867
58868   arg1 = (Dali::Toolkit::Control *)jarg1;
58869   {
58870     try {
58871       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58872     } catch (std::out_of_range& e) {
58873       {
58874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58875       };
58876     } catch (std::exception& e) {
58877       {
58878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (...) {
58881       {
58882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58883       };
58884     }
58885   }
58886   jresult = (void *)result;
58887   return jresult;
58888 }
58889
58890
58891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58892   void * jresult ;
58893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58894   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58895
58896   arg1 = (Dali::Toolkit::Control *)jarg1;
58897   {
58898     try {
58899       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58900     } catch (std::out_of_range& e) {
58901       {
58902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (std::exception& e) {
58905       {
58906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58907       };
58908     } catch (...) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58911       };
58912     }
58913   }
58914   jresult = (void *)result;
58915   return jresult;
58916 }
58917
58918
58919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58920   void * jresult ;
58921   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58922   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58923
58924   arg1 = (Dali::Toolkit::Control *)jarg1;
58925   {
58926     try {
58927       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58928     } catch (std::out_of_range& e) {
58929       {
58930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58931       };
58932     } catch (std::exception& e) {
58933       {
58934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58935       };
58936     } catch (...) {
58937       {
58938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58939       };
58940     }
58941   }
58942   jresult = (void *)result;
58943   return jresult;
58944 }
58945
58946
58947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58948   void * jresult ;
58949   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58950   Dali::Toolkit::Control *result = 0 ;
58951
58952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58953   if (!arg1) {
58954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58955     return 0;
58956   }
58957   {
58958     try {
58959       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58960     } catch (std::out_of_range& e) {
58961       {
58962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58963       };
58964     } catch (std::exception& e) {
58965       {
58966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58967       };
58968     } catch (...) {
58969       {
58970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58971       };
58972     }
58973   }
58974   jresult = (void *)result;
58975   return jresult;
58976 }
58977
58978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58979 {
58980   void * jresult;
58981   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58982   arg1 = (Dali::Toolkit::Control *)jarg1;
58983
58984   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58985
58986   Dali::Toolkit::TransitionData *arg2 = 0 ;
58987   Dali::Animation result;
58988
58989   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58990   if (!arg2) {
58991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58992     return 0;
58993   }
58994   {
58995     try {
58996       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
58997     } catch (std::out_of_range& e) {
58998       {
58999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59000       };
59001     } catch (std::exception& e) {
59002       {
59003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59004       };
59005     } catch (...) {
59006       {
59007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59008       };
59009     }
59010   }
59011   jresult = new Dali::Animation((const Dali::Animation &)result);
59012   return jresult;
59013 }
59014
59015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
59016   void * jresult ;
59017   Dali::Toolkit::Control *arg1 = 0 ;
59018   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
59019
59020   arg1 = (Dali::Toolkit::Control *)jarg1;
59021   if (!arg1) {
59022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59023     return 0;
59024   }
59025   {
59026     try {
59027       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
59028     } catch (std::out_of_range& e) {
59029       {
59030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59031       };
59032     } catch (std::exception& e) {
59033       {
59034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59035       };
59036     } catch (...) {
59037       {
59038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59039       };
59040     }
59041   }
59042   jresult = (void *)result;
59043   return jresult;
59044 }
59045
59046
59047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59048   unsigned int jresult ;
59049   Dali::Toolkit::Control *arg1 = 0 ;
59050   bool result;
59051
59052   arg1 = (Dali::Toolkit::Control *)jarg1;
59053   if (!arg1) {
59054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59055     return 0;
59056   }
59057   {
59058     try {
59059       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
59060     } catch (std::out_of_range& e) {
59061       {
59062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59063       };
59064     } catch (std::exception& e) {
59065       {
59066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59067       };
59068     } catch (...) {
59069       {
59070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59071       };
59072     }
59073   }
59074   jresult = result;
59075   return jresult;
59076 }
59077
59078
59079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59080   void * jresult ;
59081   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59082
59083   {
59084     try {
59085       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59086     } catch (std::out_of_range& e) {
59087       {
59088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59089       };
59090     } catch (std::exception& e) {
59091       {
59092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59093       };
59094     } catch (...) {
59095       {
59096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59097       };
59098     }
59099   }
59100   jresult = (void *)result;
59101   return jresult;
59102 }
59103
59104
59105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59106   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59107
59108   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59109   {
59110     try {
59111       delete arg1;
59112     } catch (std::out_of_range& e) {
59113       {
59114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59115       };
59116     } catch (std::exception& e) {
59117       {
59118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59119       };
59120     } catch (...) {
59121       {
59122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59123       };
59124     }
59125   }
59126 }
59127
59128
59129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59130   void * jresult ;
59131   Dali::Toolkit::KeyInputFocusManager result;
59132
59133   {
59134     try {
59135       result = Dali::Toolkit::KeyInputFocusManager::Get();
59136     } catch (std::out_of_range& e) {
59137       {
59138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59139       };
59140     } catch (std::exception& e) {
59141       {
59142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59143       };
59144     } catch (...) {
59145       {
59146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59147       };
59148     }
59149   }
59150   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59151   return jresult;
59152 }
59153
59154
59155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59156   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59157   Dali::Toolkit::Control arg2 ;
59158   Dali::Toolkit::Control *argp2 ;
59159
59160   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59161   argp2 = (Dali::Toolkit::Control *)jarg2;
59162   if (!argp2) {
59163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59164     return ;
59165   }
59166   arg2 = *argp2;
59167   {
59168     try {
59169       (arg1)->SetFocus(arg2);
59170     } catch (std::out_of_range& e) {
59171       {
59172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59173       };
59174     } catch (std::exception& e) {
59175       {
59176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59177       };
59178     } catch (...) {
59179       {
59180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59181       };
59182     }
59183   }
59184 }
59185
59186
59187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59188   void * jresult ;
59189   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59190   Dali::Toolkit::Control result;
59191
59192   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59193   {
59194     try {
59195       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59196     } catch (std::out_of_range& e) {
59197       {
59198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59199       };
59200     } catch (std::exception& e) {
59201       {
59202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59203       };
59204     } catch (...) {
59205       {
59206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59207       };
59208     }
59209   }
59210   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59211   return jresult;
59212 }
59213
59214
59215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59216   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59217   Dali::Toolkit::Control arg2 ;
59218   Dali::Toolkit::Control *argp2 ;
59219
59220   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59221   argp2 = (Dali::Toolkit::Control *)jarg2;
59222   if (!argp2) {
59223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59224     return ;
59225   }
59226   arg2 = *argp2;
59227   {
59228     try {
59229       (arg1)->RemoveFocus(arg2);
59230     } catch (std::out_of_range& e) {
59231       {
59232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59233       };
59234     } catch (std::exception& e) {
59235       {
59236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59237       };
59238     } catch (...) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59241       };
59242     }
59243   }
59244 }
59245
59246
59247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59248   void * jresult ;
59249   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59250   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59251
59252   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59253   {
59254     try {
59255       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59256     } catch (std::out_of_range& e) {
59257       {
59258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59259       };
59260     } catch (std::exception& e) {
59261       {
59262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59263       };
59264     } catch (...) {
59265       {
59266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59267       };
59268     }
59269   }
59270   jresult = (void *)result;
59271   return jresult;
59272 }
59273
59274
59275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59276   void * jresult ;
59277   Dali::Toolkit::Alignment::Padding *result = 0 ;
59278
59279   {
59280     try {
59281       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59282     } catch (std::out_of_range& e) {
59283       {
59284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59285       };
59286     } catch (std::exception& e) {
59287       {
59288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59289       };
59290     } catch (...) {
59291       {
59292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59293       };
59294     }
59295   }
59296   jresult = (void *)result;
59297   return jresult;
59298 }
59299
59300
59301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59302   void * jresult ;
59303   float arg1 ;
59304   float arg2 ;
59305   float arg3 ;
59306   float arg4 ;
59307   Dali::Toolkit::Alignment::Padding *result = 0 ;
59308
59309   arg1 = (float)jarg1;
59310   arg2 = (float)jarg2;
59311   arg3 = (float)jarg3;
59312   arg4 = (float)jarg4;
59313   {
59314     try {
59315       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59316     } catch (std::out_of_range& e) {
59317       {
59318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59319       };
59320     } catch (std::exception& e) {
59321       {
59322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59323       };
59324     } catch (...) {
59325       {
59326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59327       };
59328     }
59329   }
59330   jresult = (void *)result;
59331   return jresult;
59332 }
59333
59334
59335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59336   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59337   float arg2 ;
59338
59339   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59340   arg2 = (float)jarg2;
59341   if (arg1) (arg1)->left = arg2;
59342 }
59343
59344
59345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59346   float jresult ;
59347   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59348   float result;
59349
59350   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59351   result = (float) ((arg1)->left);
59352   jresult = result;
59353   return jresult;
59354 }
59355
59356
59357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59358   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59359   float arg2 ;
59360
59361   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59362   arg2 = (float)jarg2;
59363   if (arg1) (arg1)->right = arg2;
59364 }
59365
59366
59367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59368   float jresult ;
59369   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59370   float result;
59371
59372   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59373   result = (float) ((arg1)->right);
59374   jresult = result;
59375   return jresult;
59376 }
59377
59378
59379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59380   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59381   float arg2 ;
59382
59383   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59384   arg2 = (float)jarg2;
59385   if (arg1) (arg1)->top = arg2;
59386 }
59387
59388
59389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59390   float jresult ;
59391   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59392   float result;
59393
59394   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59395   result = (float) ((arg1)->top);
59396   jresult = result;
59397   return jresult;
59398 }
59399
59400
59401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59402   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59403   float arg2 ;
59404
59405   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59406   arg2 = (float)jarg2;
59407   if (arg1) (arg1)->bottom = arg2;
59408 }
59409
59410
59411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59412   float jresult ;
59413   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59414   float result;
59415
59416   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59417   result = (float) ((arg1)->bottom);
59418   jresult = result;
59419   return jresult;
59420 }
59421
59422
59423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59424   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59425
59426   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59427   {
59428     try {
59429       delete arg1;
59430     } catch (std::out_of_range& e) {
59431       {
59432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59433       };
59434     } catch (std::exception& e) {
59435       {
59436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59437       };
59438     } catch (...) {
59439       {
59440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59441       };
59442     }
59443   }
59444 }
59445
59446
59447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59448   void * jresult ;
59449   Dali::Toolkit::Alignment *result = 0 ;
59450
59451   {
59452     try {
59453       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59454     } catch (std::out_of_range& e) {
59455       {
59456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (std::exception& e) {
59459       {
59460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59461       };
59462     } catch (...) {
59463       {
59464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59465       };
59466     }
59467   }
59468   jresult = (void *)result;
59469   return jresult;
59470 }
59471
59472
59473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59474   void * jresult ;
59475   Dali::Toolkit::Alignment::Type arg1 ;
59476   Dali::Toolkit::Alignment::Type arg2 ;
59477   Dali::Toolkit::Alignment result;
59478
59479   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59480   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59481   {
59482     try {
59483       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (...) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59495       };
59496     }
59497   }
59498   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59504   void * jresult ;
59505   Dali::Toolkit::Alignment::Type arg1 ;
59506   Dali::Toolkit::Alignment result;
59507
59508   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59509   {
59510     try {
59511       result = Dali::Toolkit::Alignment::New(arg1);
59512     } catch (std::out_of_range& e) {
59513       {
59514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59515       };
59516     } catch (std::exception& e) {
59517       {
59518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59519       };
59520     } catch (...) {
59521       {
59522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59523       };
59524     }
59525   }
59526   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59527   return jresult;
59528 }
59529
59530
59531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59532   void * jresult ;
59533   Dali::Toolkit::Alignment result;
59534
59535   {
59536     try {
59537       result = Dali::Toolkit::Alignment::New();
59538     } catch (std::out_of_range& e) {
59539       {
59540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (std::exception& e) {
59543       {
59544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59553   return jresult;
59554 }
59555
59556
59557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59558   void * jresult ;
59559   Dali::Toolkit::Alignment *arg1 = 0 ;
59560   Dali::Toolkit::Alignment *result = 0 ;
59561
59562   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59563   if (!arg1) {
59564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59565     return 0;
59566   }
59567   {
59568     try {
59569       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59570     } catch (std::out_of_range& e) {
59571       {
59572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59573       };
59574     } catch (std::exception& e) {
59575       {
59576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59577       };
59578     } catch (...) {
59579       {
59580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59581       };
59582     }
59583   }
59584   jresult = (void *)result;
59585   return jresult;
59586 }
59587
59588
59589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59590   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59591
59592   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59593   {
59594     try {
59595       delete arg1;
59596     } catch (std::out_of_range& e) {
59597       {
59598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59599       };
59600     } catch (std::exception& e) {
59601       {
59602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59603       };
59604     } catch (...) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59607       };
59608     }
59609   }
59610 }
59611
59612
59613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59614   void * jresult ;
59615   Dali::BaseHandle arg1 ;
59616   Dali::BaseHandle *argp1 ;
59617   Dali::Toolkit::Alignment result;
59618
59619   argp1 = (Dali::BaseHandle *)jarg1;
59620   if (!argp1) {
59621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59622     return 0;
59623   }
59624   arg1 = *argp1;
59625   {
59626     try {
59627       result = Dali::Toolkit::Alignment::DownCast(arg1);
59628     } catch (std::out_of_range& e) {
59629       {
59630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59631       };
59632     } catch (std::exception& e) {
59633       {
59634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59635       };
59636     } catch (...) {
59637       {
59638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59639       };
59640     }
59641   }
59642   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59643   return jresult;
59644 }
59645
59646
59647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59648   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59649   Dali::Toolkit::Alignment::Type arg2 ;
59650
59651   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59652   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59653   {
59654     try {
59655       (arg1)->SetAlignmentType(arg2);
59656     } catch (std::out_of_range& e) {
59657       {
59658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59659       };
59660     } catch (std::exception& e) {
59661       {
59662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59663       };
59664     } catch (...) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59667       };
59668     }
59669   }
59670 }
59671
59672
59673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59674   int jresult ;
59675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59676   Dali::Toolkit::Alignment::Type result;
59677
59678   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59679   {
59680     try {
59681       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59682     } catch (std::out_of_range& e) {
59683       {
59684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (std::exception& e) {
59687       {
59688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (...) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59693       };
59694     }
59695   }
59696   jresult = (int)result;
59697   return jresult;
59698 }
59699
59700
59701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59702   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59703   Dali::Toolkit::Alignment::Scaling arg2 ;
59704
59705   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59706   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59707   {
59708     try {
59709       (arg1)->SetScaling(arg2);
59710     } catch (std::out_of_range& e) {
59711       {
59712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59713       };
59714     } catch (std::exception& e) {
59715       {
59716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59717       };
59718     } catch (...) {
59719       {
59720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59721       };
59722     }
59723   }
59724 }
59725
59726
59727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59728   int jresult ;
59729   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59730   Dali::Toolkit::Alignment::Scaling result;
59731
59732   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59733   {
59734     try {
59735       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59736     } catch (std::out_of_range& e) {
59737       {
59738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59739       };
59740     } catch (std::exception& e) {
59741       {
59742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (...) {
59745       {
59746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59747       };
59748     }
59749   }
59750   jresult = (int)result;
59751   return jresult;
59752 }
59753
59754
59755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59756   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59757   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59758
59759   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59760   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59761   if (!arg2) {
59762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59763     return ;
59764   }
59765   {
59766     try {
59767       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59768     } catch (std::out_of_range& e) {
59769       {
59770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59771       };
59772     } catch (std::exception& e) {
59773       {
59774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59775       };
59776     } catch (...) {
59777       {
59778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59779       };
59780     }
59781   }
59782 }
59783
59784
59785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59786   void * jresult ;
59787   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59788   Dali::Toolkit::Alignment::Padding *result = 0 ;
59789
59790   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59791   {
59792     try {
59793       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59794     } catch (std::out_of_range& e) {
59795       {
59796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59797       };
59798     } catch (std::exception& e) {
59799       {
59800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59801       };
59802     } catch (...) {
59803       {
59804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59805       };
59806     }
59807   }
59808   jresult = (void *)result;
59809   return jresult;
59810 }
59811
59812
59813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59814   void * jresult ;
59815   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59816   Dali::Toolkit::Alignment *arg2 = 0 ;
59817   Dali::Toolkit::Alignment *result = 0 ;
59818
59819   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59820   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59821   if (!arg2) {
59822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59823     return 0;
59824   }
59825   {
59826     try {
59827       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59828     } catch (std::out_of_range& e) {
59829       {
59830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59831       };
59832     } catch (std::exception& e) {
59833       {
59834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59835       };
59836     } catch (...) {
59837       {
59838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59839       };
59840     }
59841   }
59842   jresult = (void *)result;
59843   return jresult;
59844 }
59845
59846
59847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59848   int jresult ;
59849   int result;
59850
59851   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59852   jresult = (int)result;
59853   return jresult;
59854 }
59855
59856
59857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59858   int jresult ;
59859   int result;
59860
59861   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866
59867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59868   int jresult ;
59869   int result;
59870
59871   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59872   jresult = (int)result;
59873   return jresult;
59874 }
59875
59876
59877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59878   int jresult ;
59879   int result;
59880
59881   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59882   jresult = (int)result;
59883   return jresult;
59884 }
59885
59886
59887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59888   int jresult ;
59889   int result;
59890
59891   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59898   int jresult ;
59899   int result;
59900
59901   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59902   jresult = (int)result;
59903   return jresult;
59904 }
59905
59906
59907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59908   int jresult ;
59909   int result;
59910
59911   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59912   jresult = (int)result;
59913   return jresult;
59914 }
59915
59916
59917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59918   int jresult ;
59919   int result;
59920
59921   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59922   jresult = (int)result;
59923   return jresult;
59924 }
59925
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59928   int jresult ;
59929   int result;
59930
59931   result = (int)Dali::Toolkit::Button::Property::LABEL;
59932   jresult = (int)result;
59933   return jresult;
59934 }
59935
59936
59937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59938   int jresult ;
59939   int result;
59940
59941   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59942   jresult = (int)result;
59943   return jresult;
59944 }
59945
59946
59947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59948   void * jresult ;
59949   Dali::Toolkit::Button::Property *result = 0 ;
59950
59951   {
59952     try {
59953       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59954     } catch (std::out_of_range& e) {
59955       {
59956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59957       };
59958     } catch (std::exception& e) {
59959       {
59960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59961       };
59962     } catch (...) {
59963       {
59964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59965       };
59966     }
59967   }
59968   jresult = (void *)result;
59969   return jresult;
59970 }
59971
59972
59973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59974   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59975
59976   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59977   {
59978     try {
59979       delete arg1;
59980     } catch (std::out_of_range& e) {
59981       {
59982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59983       };
59984     } catch (std::exception& e) {
59985       {
59986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59987       };
59988     } catch (...) {
59989       {
59990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59991       };
59992     }
59993   }
59994 }
59995
59996
59997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59998   void * jresult ;
59999   Dali::Toolkit::Button *result = 0 ;
60000
60001   {
60002     try {
60003       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018   jresult = (void *)result;
60019   return jresult;
60020 }
60021
60022
60023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60024   void * jresult ;
60025   Dali::Toolkit::Button *arg1 = 0 ;
60026   Dali::Toolkit::Button *result = 0 ;
60027
60028   arg1 = (Dali::Toolkit::Button *)jarg1;
60029   if (!arg1) {
60030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60031     return 0;
60032   }
60033   {
60034     try {
60035       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60036     } catch (std::out_of_range& e) {
60037       {
60038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60039       };
60040     } catch (std::exception& e) {
60041       {
60042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60043       };
60044     } catch (...) {
60045       {
60046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60047       };
60048     }
60049   }
60050   jresult = (void *)result;
60051   return jresult;
60052 }
60053
60054
60055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60056   void * jresult ;
60057   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60058   Dali::Toolkit::Button *arg2 = 0 ;
60059   Dali::Toolkit::Button *result = 0 ;
60060
60061   arg1 = (Dali::Toolkit::Button *)jarg1;
60062   arg2 = (Dali::Toolkit::Button *)jarg2;
60063   if (!arg2) {
60064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60065     return 0;
60066   }
60067   {
60068     try {
60069       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60070     } catch (std::out_of_range& e) {
60071       {
60072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60073       };
60074     } catch (std::exception& e) {
60075       {
60076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60077       };
60078     } catch (...) {
60079       {
60080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60081       };
60082     }
60083   }
60084   jresult = (void *)result;
60085   return jresult;
60086 }
60087
60088
60089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60090   void * jresult ;
60091   Dali::BaseHandle arg1 ;
60092   Dali::BaseHandle *argp1 ;
60093   Dali::Toolkit::Button result;
60094
60095   argp1 = (Dali::BaseHandle *)jarg1;
60096   if (!argp1) {
60097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60098     return 0;
60099   }
60100   arg1 = *argp1;
60101   {
60102     try {
60103       result = Dali::Toolkit::Button::DownCast(arg1);
60104     } catch (std::out_of_range& e) {
60105       {
60106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60107       };
60108     } catch (std::exception& e) {
60109       {
60110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60111       };
60112     } catch (...) {
60113       {
60114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60115       };
60116     }
60117   }
60118   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60119   return jresult;
60120 }
60121
60122
60123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60124   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60125
60126   arg1 = (Dali::Toolkit::Button *)jarg1;
60127   {
60128     try {
60129       delete arg1;
60130     } catch (std::out_of_range& e) {
60131       {
60132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60133       };
60134     } catch (std::exception& e) {
60135       {
60136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60137       };
60138     } catch (...) {
60139       {
60140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60141       };
60142     }
60143   }
60144 }
60145
60146
60147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60148   unsigned int jresult ;
60149   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60150   bool result;
60151
60152   arg1 = (Dali::Toolkit::Button *)jarg1;
60153   {
60154     try {
60155       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60156     } catch (std::out_of_range& e) {
60157       {
60158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60159       };
60160     } catch (std::exception& e) {
60161       {
60162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60163       };
60164     } catch (...) {
60165       {
60166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60167       };
60168     }
60169   }
60170   jresult = result;
60171   return jresult;
60172 }
60173
60174
60175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60176   unsigned int jresult ;
60177   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60178   bool result;
60179
60180   arg1 = (Dali::Toolkit::Button *)jarg1;
60181   {
60182     try {
60183       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60184     } catch (std::out_of_range& e) {
60185       {
60186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60187       };
60188     } catch (std::exception& e) {
60189       {
60190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60191       };
60192     } catch (...) {
60193       {
60194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60195       };
60196     }
60197   }
60198   jresult = result;
60199   return jresult;
60200 }
60201
60202
60203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60204   float jresult ;
60205   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60206   float result;
60207
60208   arg1 = (Dali::Toolkit::Button *)jarg1;
60209   {
60210     try {
60211       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60219       };
60220     } catch (...) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60223       };
60224     }
60225   }
60226   jresult = result;
60227   return jresult;
60228 }
60229
60230
60231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60232   float jresult ;
60233   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60234   float result;
60235
60236   arg1 = (Dali::Toolkit::Button *)jarg1;
60237   {
60238     try {
60239       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60240     } catch (std::out_of_range& e) {
60241       {
60242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60243       };
60244     } catch (std::exception& e) {
60245       {
60246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60251       };
60252     }
60253   }
60254   jresult = result;
60255   return jresult;
60256 }
60257
60258
60259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60260   unsigned int jresult ;
60261   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60262   bool result;
60263
60264   arg1 = (Dali::Toolkit::Button *)jarg1;
60265   {
60266     try {
60267       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60275       };
60276     } catch (...) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60279       };
60280     }
60281   }
60282   jresult = result;
60283   return jresult;
60284 }
60285
60286
60287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60288   unsigned int jresult ;
60289   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60290   bool result;
60291
60292   arg1 = (Dali::Toolkit::Button *)jarg1;
60293   {
60294     try {
60295       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (...) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60307       };
60308     }
60309   }
60310   jresult = result;
60311   return jresult;
60312 }
60313
60314
60315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60316   float jresult ;
60317   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60318   float result;
60319
60320   arg1 = (Dali::Toolkit::Button *)jarg1;
60321   {
60322     try {
60323       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60324     } catch (std::out_of_range& e) {
60325       {
60326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (std::exception& e) {
60329       {
60330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60335       };
60336     }
60337   }
60338   jresult = result;
60339   return jresult;
60340 }
60341
60342
60343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60344   char * jresult ;
60345   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60346   std::string result;
60347
60348   arg1 = (Dali::Toolkit::Button *)jarg1;
60349   {
60350     try {
60351       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60352     } catch (std::out_of_range& e) {
60353       {
60354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60355       };
60356     } catch (std::exception& e) {
60357       {
60358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60359       };
60360     } catch (...) {
60361       {
60362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60363       };
60364     }
60365   }
60366   jresult = SWIG_csharp_string_callback((&result)->c_str());
60367   return jresult;
60368 }
60369
60370
60371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60372   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60373   Dali::Actor arg2 ;
60374   Dali::Actor *argp2 ;
60375
60376   arg1 = (Dali::Toolkit::Button *)jarg1;
60377   argp2 = (Dali::Actor *)jarg2;
60378   if (!argp2) {
60379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60380     return ;
60381   }
60382   arg2 = *argp2;
60383   {
60384     try {
60385       (arg1)->SetLabel(arg2);
60386     } catch (std::out_of_range& e) {
60387       {
60388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60389       };
60390     } catch (std::exception& e) {
60391       {
60392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60393       };
60394     } catch (...) {
60395       {
60396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60397       };
60398     }
60399   }
60400 }
60401
60402
60403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60404   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60405   Dali::Image arg2 ;
60406   Dali::Image *argp2 ;
60407
60408   arg1 = (Dali::Toolkit::Button *)jarg1;
60409   argp2 = (Dali::Image *)jarg2;
60410   if (!argp2) {
60411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60412     return ;
60413   }
60414   arg2 = *argp2;
60415   {
60416     try {
60417       (arg1)->SetButtonImage(arg2);
60418     } catch (std::out_of_range& e) {
60419       {
60420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60421       };
60422     } catch (std::exception& e) {
60423       {
60424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60425       };
60426     } catch (...) {
60427       {
60428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60429       };
60430     }
60431   }
60432 }
60433
60434
60435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60436   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60437   Dali::Image arg2 ;
60438   Dali::Image *argp2 ;
60439
60440   arg1 = (Dali::Toolkit::Button *)jarg1;
60441   argp2 = (Dali::Image *)jarg2;
60442   if (!argp2) {
60443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60444     return ;
60445   }
60446   arg2 = *argp2;
60447   {
60448     try {
60449       (arg1)->SetSelectedImage(arg2);
60450     } catch (std::out_of_range& e) {
60451       {
60452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60453       };
60454     } catch (std::exception& e) {
60455       {
60456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60457       };
60458     } catch (...) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60461       };
60462     }
60463   }
60464 }
60465
60466
60467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60468   void * jresult ;
60469   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60470   Dali::Actor result;
60471
60472   arg1 = (Dali::Toolkit::Button *)jarg1;
60473   {
60474     try {
60475       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60476     } catch (std::out_of_range& e) {
60477       {
60478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60479       };
60480     } catch (std::exception& e) {
60481       {
60482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60487       };
60488     }
60489   }
60490   jresult = new Dali::Actor((const Dali::Actor &)result);
60491   return jresult;
60492 }
60493
60494
60495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60496   void * jresult ;
60497   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60498   Dali::Actor result;
60499
60500   arg1 = (Dali::Toolkit::Button *)jarg1;
60501   {
60502     try {
60503       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60504     } catch (std::out_of_range& e) {
60505       {
60506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60507       };
60508     } catch (std::exception& e) {
60509       {
60510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60511       };
60512     } catch (...) {
60513       {
60514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60515       };
60516     }
60517   }
60518   jresult = new Dali::Actor((const Dali::Actor &)result);
60519   return jresult;
60520 }
60521
60522
60523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60524   void * jresult ;
60525   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60526   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60527
60528   arg1 = (Dali::Toolkit::Button *)jarg1;
60529   {
60530     try {
60531       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60539       };
60540     } catch (...) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60543       };
60544     }
60545   }
60546   jresult = (void *)result;
60547   return jresult;
60548 }
60549
60550
60551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60552   void * jresult ;
60553   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60554   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60555
60556   arg1 = (Dali::Toolkit::Button *)jarg1;
60557   {
60558     try {
60559       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60560     } catch (std::out_of_range& e) {
60561       {
60562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60563       };
60564     } catch (std::exception& e) {
60565       {
60566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60567       };
60568     } catch (...) {
60569       {
60570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60571       };
60572     }
60573   }
60574   jresult = (void *)result;
60575   return jresult;
60576 }
60577
60578
60579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60580   void * jresult ;
60581   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60582   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60583
60584   arg1 = (Dali::Toolkit::Button *)jarg1;
60585   {
60586     try {
60587       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60588     } catch (std::out_of_range& e) {
60589       {
60590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (std::exception& e) {
60593       {
60594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (...) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60599       };
60600     }
60601   }
60602   jresult = (void *)result;
60603   return jresult;
60604 }
60605
60606
60607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60608   void * jresult ;
60609   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60610   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60611
60612   arg1 = (Dali::Toolkit::Button *)jarg1;
60613   {
60614     try {
60615       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60616     } catch (std::out_of_range& e) {
60617       {
60618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60619       };
60620     } catch (std::exception& e) {
60621       {
60622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60623       };
60624     } catch (...) {
60625       {
60626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60627       };
60628     }
60629   }
60630   jresult = (void *)result;
60631   return jresult;
60632 }
60633
60634
60635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60636   void * jresult ;
60637   Dali::Toolkit::CheckBoxButton *result = 0 ;
60638
60639   {
60640     try {
60641       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60642     } catch (std::out_of_range& e) {
60643       {
60644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (std::exception& e) {
60647       {
60648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60653       };
60654     }
60655   }
60656   jresult = (void *)result;
60657   return jresult;
60658 }
60659
60660
60661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60662   void * jresult ;
60663   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60664   Dali::Toolkit::CheckBoxButton *result = 0 ;
60665
60666   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60667   if (!arg1) {
60668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60669     return 0;
60670   }
60671   {
60672     try {
60673       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60674     } catch (std::out_of_range& e) {
60675       {
60676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60677       };
60678     } catch (std::exception& e) {
60679       {
60680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60681       };
60682     } catch (...) {
60683       {
60684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60685       };
60686     }
60687   }
60688   jresult = (void *)result;
60689   return jresult;
60690 }
60691
60692
60693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60694   void * jresult ;
60695   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60696   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60697   Dali::Toolkit::CheckBoxButton *result = 0 ;
60698
60699   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60700   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60701   if (!arg2) {
60702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60703     return 0;
60704   }
60705   {
60706     try {
60707       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60708     } catch (std::out_of_range& e) {
60709       {
60710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60711       };
60712     } catch (std::exception& e) {
60713       {
60714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (...) {
60717       {
60718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60719       };
60720     }
60721   }
60722   jresult = (void *)result;
60723   return jresult;
60724 }
60725
60726
60727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60728   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60729
60730   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60731   {
60732     try {
60733       delete arg1;
60734     } catch (std::out_of_range& e) {
60735       {
60736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60737       };
60738     } catch (std::exception& e) {
60739       {
60740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60741       };
60742     } catch (...) {
60743       {
60744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60745       };
60746     }
60747   }
60748 }
60749
60750
60751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60752   void * jresult ;
60753   Dali::Toolkit::CheckBoxButton result;
60754
60755   {
60756     try {
60757       result = Dali::Toolkit::CheckBoxButton::New();
60758     } catch (std::out_of_range& e) {
60759       {
60760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60761       };
60762     } catch (std::exception& e) {
60763       {
60764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60765       };
60766     } catch (...) {
60767       {
60768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60769       };
60770     }
60771   }
60772   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60773   return jresult;
60774 }
60775
60776
60777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60778   void * jresult ;
60779   Dali::BaseHandle arg1 ;
60780   Dali::BaseHandle *argp1 ;
60781   Dali::Toolkit::CheckBoxButton result;
60782
60783   argp1 = (Dali::BaseHandle *)jarg1;
60784   if (!argp1) {
60785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60786     return 0;
60787   }
60788   arg1 = *argp1;
60789   {
60790     try {
60791       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60792     } catch (std::out_of_range& e) {
60793       {
60794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60795       };
60796     } catch (std::exception& e) {
60797       {
60798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60799       };
60800     } catch (...) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60803       };
60804     }
60805   }
60806   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60807   return jresult;
60808 }
60809
60810
60811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60812   int jresult ;
60813   int result;
60814
60815   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60816   jresult = (int)result;
60817   return jresult;
60818 }
60819
60820
60821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60822   int jresult ;
60823   int result;
60824
60825   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60826   jresult = (int)result;
60827   return jresult;
60828 }
60829
60830
60831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60832   int jresult ;
60833   int result;
60834
60835   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60836   jresult = (int)result;
60837   return jresult;
60838 }
60839
60840
60841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60842   int jresult ;
60843   int result;
60844
60845   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60846   jresult = (int)result;
60847   return jresult;
60848 }
60849
60850
60851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60852   int jresult ;
60853   int result;
60854
60855   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60856   jresult = (int)result;
60857   return jresult;
60858 }
60859
60860
60861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60862   void * jresult ;
60863   Dali::Toolkit::PushButton::Property *result = 0 ;
60864
60865   {
60866     try {
60867       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60868     } catch (std::out_of_range& e) {
60869       {
60870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60871       };
60872     } catch (std::exception& e) {
60873       {
60874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60875       };
60876     } catch (...) {
60877       {
60878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60879       };
60880     }
60881   }
60882   jresult = (void *)result;
60883   return jresult;
60884 }
60885
60886
60887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60888   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60889
60890   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60891   {
60892     try {
60893       delete arg1;
60894     } catch (std::out_of_range& e) {
60895       {
60896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60897       };
60898     } catch (std::exception& e) {
60899       {
60900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60901       };
60902     } catch (...) {
60903       {
60904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60905       };
60906     }
60907   }
60908 }
60909
60910
60911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60912   void * jresult ;
60913   Dali::Toolkit::PushButton *result = 0 ;
60914
60915   {
60916     try {
60917       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60918     } catch (std::out_of_range& e) {
60919       {
60920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60921       };
60922     } catch (std::exception& e) {
60923       {
60924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60925       };
60926     } catch (...) {
60927       {
60928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60929       };
60930     }
60931   }
60932   jresult = (void *)result;
60933   return jresult;
60934 }
60935
60936
60937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60938   void * jresult ;
60939   Dali::Toolkit::PushButton *arg1 = 0 ;
60940   Dali::Toolkit::PushButton *result = 0 ;
60941
60942   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60943   if (!arg1) {
60944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60945     return 0;
60946   }
60947   {
60948     try {
60949       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60950     } catch (std::out_of_range& e) {
60951       {
60952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (std::exception& e) {
60955       {
60956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (...) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60961       };
60962     }
60963   }
60964   jresult = (void *)result;
60965   return jresult;
60966 }
60967
60968
60969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60970   void * jresult ;
60971   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60972   Dali::Toolkit::PushButton *arg2 = 0 ;
60973   Dali::Toolkit::PushButton *result = 0 ;
60974
60975   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60976   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60977   if (!arg2) {
60978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60979     return 0;
60980   }
60981   {
60982     try {
60983       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
60984     } catch (std::out_of_range& e) {
60985       {
60986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60987       };
60988     } catch (std::exception& e) {
60989       {
60990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60991       };
60992     } catch (...) {
60993       {
60994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60995       };
60996     }
60997   }
60998   jresult = (void *)result;
60999   return jresult;
61000 }
61001
61002
61003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
61004   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61005
61006   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61007   {
61008     try {
61009       delete arg1;
61010     } catch (std::out_of_range& e) {
61011       {
61012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61013       };
61014     } catch (std::exception& e) {
61015       {
61016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61017       };
61018     } catch (...) {
61019       {
61020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61021       };
61022     }
61023   }
61024 }
61025
61026
61027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
61028   void * jresult ;
61029   Dali::Toolkit::PushButton result;
61030
61031   {
61032     try {
61033       result = Dali::Toolkit::PushButton::New();
61034     } catch (std::out_of_range& e) {
61035       {
61036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61037       };
61038     } catch (std::exception& e) {
61039       {
61040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61041       };
61042     } catch (...) {
61043       {
61044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61045       };
61046     }
61047   }
61048   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61049   return jresult;
61050 }
61051
61052
61053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61054   void * jresult ;
61055   Dali::BaseHandle arg1 ;
61056   Dali::BaseHandle *argp1 ;
61057   Dali::Toolkit::PushButton result;
61058
61059   argp1 = (Dali::BaseHandle *)jarg1;
61060   if (!argp1) {
61061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61062     return 0;
61063   }
61064   arg1 = *argp1;
61065   {
61066     try {
61067       result = Dali::Toolkit::PushButton::DownCast(arg1);
61068     } catch (std::out_of_range& e) {
61069       {
61070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (std::exception& e) {
61073       {
61074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61079       };
61080     }
61081   }
61082   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61083   return jresult;
61084 }
61085
61086
61087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61088   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61089   Dali::Image arg2 ;
61090   Dali::Image *argp2 ;
61091
61092   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61093   argp2 = (Dali::Image *)jarg2;
61094   if (!argp2) {
61095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61096     return ;
61097   }
61098   arg2 = *argp2;
61099   {
61100     try {
61101       (arg1)->SetButtonImage(arg2);
61102     } catch (std::out_of_range& e) {
61103       {
61104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61105       };
61106     } catch (std::exception& e) {
61107       {
61108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61109       };
61110     } catch (...) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61113       };
61114     }
61115   }
61116 }
61117
61118
61119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61120   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61121   Dali::Actor arg2 ;
61122   Dali::Actor *argp2 ;
61123
61124   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61125   argp2 = (Dali::Actor *)jarg2;
61126   if (!argp2) {
61127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61128     return ;
61129   }
61130   arg2 = *argp2;
61131   {
61132     try {
61133       (arg1)->SetButtonImage(arg2);
61134     } catch (std::out_of_range& e) {
61135       {
61136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61137       };
61138     } catch (std::exception& e) {
61139       {
61140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61141       };
61142     } catch (...) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61145       };
61146     }
61147   }
61148 }
61149
61150
61151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61152   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61153   Dali::Actor arg2 ;
61154   Dali::Actor *argp2 ;
61155
61156   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61157   argp2 = (Dali::Actor *)jarg2;
61158   if (!argp2) {
61159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61160     return ;
61161   }
61162   arg2 = *argp2;
61163   {
61164     try {
61165       (arg1)->SetBackgroundImage(arg2);
61166     } catch (std::out_of_range& e) {
61167       {
61168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61169       };
61170     } catch (std::exception& e) {
61171       {
61172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61173       };
61174     } catch (...) {
61175       {
61176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61177       };
61178     }
61179   }
61180 }
61181
61182
61183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61184   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61185   Dali::Image arg2 ;
61186   Dali::Image *argp2 ;
61187
61188   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61189   argp2 = (Dali::Image *)jarg2;
61190   if (!argp2) {
61191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61192     return ;
61193   }
61194   arg2 = *argp2;
61195   {
61196     try {
61197       (arg1)->SetSelectedImage(arg2);
61198     } catch (std::out_of_range& e) {
61199       {
61200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61201       };
61202     } catch (std::exception& e) {
61203       {
61204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61205       };
61206     } catch (...) {
61207       {
61208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61209       };
61210     }
61211   }
61212 }
61213
61214
61215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61216   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61217   Dali::Actor arg2 ;
61218   Dali::Actor *argp2 ;
61219
61220   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61221   argp2 = (Dali::Actor *)jarg2;
61222   if (!argp2) {
61223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61224     return ;
61225   }
61226   arg2 = *argp2;
61227   {
61228     try {
61229       (arg1)->SetSelectedImage(arg2);
61230     } catch (std::out_of_range& e) {
61231       {
61232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61233       };
61234     } catch (std::exception& e) {
61235       {
61236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61241       };
61242     }
61243   }
61244 }
61245
61246
61247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61248   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61249   Dali::Actor arg2 ;
61250   Dali::Actor *argp2 ;
61251
61252   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61253   argp2 = (Dali::Actor *)jarg2;
61254   if (!argp2) {
61255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61256     return ;
61257   }
61258   arg2 = *argp2;
61259   {
61260     try {
61261       (arg1)->SetSelectedBackgroundImage(arg2);
61262     } catch (std::out_of_range& e) {
61263       {
61264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61265       };
61266     } catch (std::exception& e) {
61267       {
61268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61269       };
61270     } catch (...) {
61271       {
61272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61273       };
61274     }
61275   }
61276 }
61277
61278
61279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61280   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61281   Dali::Actor arg2 ;
61282   Dali::Actor *argp2 ;
61283
61284   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61285   argp2 = (Dali::Actor *)jarg2;
61286   if (!argp2) {
61287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61288     return ;
61289   }
61290   arg2 = *argp2;
61291   {
61292     try {
61293       (arg1)->SetDisabledBackgroundImage(arg2);
61294     } catch (std::out_of_range& e) {
61295       {
61296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61297       };
61298     } catch (std::exception& e) {
61299       {
61300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61301       };
61302     } catch (...) {
61303       {
61304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61305       };
61306     }
61307   }
61308 }
61309
61310
61311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61312   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61313   Dali::Actor arg2 ;
61314   Dali::Actor *argp2 ;
61315
61316   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61317   argp2 = (Dali::Actor *)jarg2;
61318   if (!argp2) {
61319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61320     return ;
61321   }
61322   arg2 = *argp2;
61323   {
61324     try {
61325       (arg1)->SetDisabledImage(arg2);
61326     } catch (std::out_of_range& e) {
61327       {
61328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61329       };
61330     } catch (std::exception& e) {
61331       {
61332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61333       };
61334     } catch (...) {
61335       {
61336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61337       };
61338     }
61339   }
61340 }
61341
61342
61343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61344   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61345   Dali::Actor arg2 ;
61346   Dali::Actor *argp2 ;
61347
61348   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61349   argp2 = (Dali::Actor *)jarg2;
61350   if (!argp2) {
61351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61352     return ;
61353   }
61354   arg2 = *argp2;
61355   {
61356     try {
61357       (arg1)->SetDisabledSelectedImage(arg2);
61358     } catch (std::out_of_range& e) {
61359       {
61360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61361       };
61362     } catch (std::exception& e) {
61363       {
61364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61365       };
61366     } catch (...) {
61367       {
61368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61369       };
61370     }
61371   }
61372 }
61373
61374
61375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61376   void * jresult ;
61377   Dali::Toolkit::RadioButton *result = 0 ;
61378
61379   {
61380     try {
61381       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61382     } catch (std::out_of_range& e) {
61383       {
61384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61385       };
61386     } catch (std::exception& e) {
61387       {
61388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61389       };
61390     } catch (...) {
61391       {
61392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61393       };
61394     }
61395   }
61396   jresult = (void *)result;
61397   return jresult;
61398 }
61399
61400
61401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61402   void * jresult ;
61403   Dali::Toolkit::RadioButton *arg1 = 0 ;
61404   Dali::Toolkit::RadioButton *result = 0 ;
61405
61406   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61407   if (!arg1) {
61408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61409     return 0;
61410   }
61411   {
61412     try {
61413       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61414     } catch (std::out_of_range& e) {
61415       {
61416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (std::exception& e) {
61419       {
61420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (...) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61425       };
61426     }
61427   }
61428   jresult = (void *)result;
61429   return jresult;
61430 }
61431
61432
61433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61434   void * jresult ;
61435   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61436   Dali::Toolkit::RadioButton *arg2 = 0 ;
61437   Dali::Toolkit::RadioButton *result = 0 ;
61438
61439   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61440   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61441   if (!arg2) {
61442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61443     return 0;
61444   }
61445   {
61446     try {
61447       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61448     } catch (std::out_of_range& e) {
61449       {
61450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61451       };
61452     } catch (std::exception& e) {
61453       {
61454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61455       };
61456     } catch (...) {
61457       {
61458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61459       };
61460     }
61461   }
61462   jresult = (void *)result;
61463   return jresult;
61464 }
61465
61466
61467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61468   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61469
61470   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61471   {
61472     try {
61473       delete arg1;
61474     } catch (std::out_of_range& e) {
61475       {
61476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61477       };
61478     } catch (std::exception& e) {
61479       {
61480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61481       };
61482     } catch (...) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61485       };
61486     }
61487   }
61488 }
61489
61490
61491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61492   void * jresult ;
61493   Dali::Toolkit::RadioButton result;
61494
61495   {
61496     try {
61497       result = Dali::Toolkit::RadioButton::New();
61498     } catch (std::out_of_range& e) {
61499       {
61500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61501       };
61502     } catch (std::exception& e) {
61503       {
61504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61505       };
61506     } catch (...) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61509       };
61510     }
61511   }
61512   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61513   return jresult;
61514 }
61515
61516
61517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61518   void * jresult ;
61519   std::string *arg1 = 0 ;
61520   Dali::Toolkit::RadioButton result;
61521
61522   if (!jarg1) {
61523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61524     return 0;
61525   }
61526   std::string arg1_str(jarg1);
61527   arg1 = &arg1_str;
61528   {
61529     try {
61530       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61531     } catch (std::out_of_range& e) {
61532       {
61533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61534       };
61535     } catch (std::exception& e) {
61536       {
61537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (...) {
61540       {
61541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61542       };
61543     }
61544   }
61545   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61546
61547   //argout typemap for const std::string&
61548
61549   return jresult;
61550 }
61551
61552
61553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61554   void * jresult ;
61555   Dali::BaseHandle arg1 ;
61556   Dali::BaseHandle *argp1 ;
61557   Dali::Toolkit::RadioButton result;
61558
61559   argp1 = (Dali::BaseHandle *)jarg1;
61560   if (!argp1) {
61561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61562     return 0;
61563   }
61564   arg1 = *argp1;
61565   {
61566     try {
61567       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61568     } catch (std::out_of_range& e) {
61569       {
61570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61571       };
61572     } catch (std::exception& e) {
61573       {
61574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61575       };
61576     } catch (...) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61579       };
61580     }
61581   }
61582   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61583   return jresult;
61584 }
61585
61586
61587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61588   int jresult ;
61589   int result;
61590
61591   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61592   jresult = (int)result;
61593   return jresult;
61594 }
61595
61596
61597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61598   int jresult ;
61599   int result;
61600
61601   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61602   jresult = (int)result;
61603   return jresult;
61604 }
61605
61606
61607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61608   int jresult ;
61609   int result;
61610
61611   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61612   jresult = (int)result;
61613   return jresult;
61614 }
61615
61616
61617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61618   int jresult ;
61619   int result;
61620
61621   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61622   jresult = (int)result;
61623   return jresult;
61624 }
61625
61626
61627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61628   int jresult ;
61629   int result;
61630
61631   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61632   jresult = (int)result;
61633   return jresult;
61634 }
61635
61636
61637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61638   int jresult ;
61639   int result;
61640
61641   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61642   jresult = (int)result;
61643   return jresult;
61644 }
61645
61646
61647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61648   void * jresult ;
61649   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61650
61651   {
61652     try {
61653       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61654     } catch (std::out_of_range& e) {
61655       {
61656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61657       };
61658     } catch (std::exception& e) {
61659       {
61660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (...) {
61663       {
61664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61665       };
61666     }
61667   }
61668   jresult = (void *)result;
61669   return jresult;
61670 }
61671
61672
61673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61674   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61675
61676   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61677   {
61678     try {
61679       delete arg1;
61680     } catch (std::out_of_range& e) {
61681       {
61682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61683       };
61684     } catch (std::exception& e) {
61685       {
61686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61687       };
61688     } catch (...) {
61689       {
61690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61691       };
61692     }
61693   }
61694 }
61695
61696
61697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61698   int jresult ;
61699   int result;
61700
61701   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61702   jresult = (int)result;
61703   return jresult;
61704 }
61705
61706
61707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61708   int jresult ;
61709   int result;
61710
61711   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61712   jresult = (int)result;
61713   return jresult;
61714 }
61715
61716
61717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61718   int jresult ;
61719   int result;
61720
61721   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61722   jresult = (int)result;
61723   return jresult;
61724 }
61725
61726
61727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61728   void * jresult ;
61729   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61730
61731   {
61732     try {
61733       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61734     } catch (std::out_of_range& e) {
61735       {
61736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61737       };
61738     } catch (std::exception& e) {
61739       {
61740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61741       };
61742     } catch (...) {
61743       {
61744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61745       };
61746     }
61747   }
61748   jresult = (void *)result;
61749   return jresult;
61750 }
61751
61752
61753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61754   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61755
61756   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61757   {
61758     try {
61759       delete arg1;
61760     } catch (std::out_of_range& e) {
61761       {
61762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61763       };
61764     } catch (std::exception& e) {
61765       {
61766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61771       };
61772     }
61773   }
61774 }
61775
61776
61777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61778   void * jresult ;
61779   Dali::Toolkit::FlexContainer *result = 0 ;
61780
61781   {
61782     try {
61783       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61784     } catch (std::out_of_range& e) {
61785       {
61786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61787       };
61788     } catch (std::exception& e) {
61789       {
61790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61791       };
61792     } catch (...) {
61793       {
61794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61795       };
61796     }
61797   }
61798   jresult = (void *)result;
61799   return jresult;
61800 }
61801
61802
61803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61804   void * jresult ;
61805   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61806   Dali::Toolkit::FlexContainer *result = 0 ;
61807
61808   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61809   if (!arg1) {
61810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61811     return 0;
61812   }
61813   {
61814     try {
61815       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61823       };
61824     } catch (...) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61827       };
61828     }
61829   }
61830   jresult = (void *)result;
61831   return jresult;
61832 }
61833
61834
61835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61836   void * jresult ;
61837   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61838   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61839   Dali::Toolkit::FlexContainer *result = 0 ;
61840
61841   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61842   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61843   if (!arg2) {
61844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61845     return 0;
61846   }
61847   {
61848     try {
61849       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (...) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61861       };
61862     }
61863   }
61864   jresult = (void *)result;
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61870   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61871
61872   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61873   {
61874     try {
61875       delete arg1;
61876     } catch (std::out_of_range& e) {
61877       {
61878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61879       };
61880     } catch (std::exception& e) {
61881       {
61882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61883       };
61884     } catch (...) {
61885       {
61886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61887       };
61888     }
61889   }
61890 }
61891
61892
61893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61894   void * jresult ;
61895   Dali::Toolkit::FlexContainer result;
61896
61897   {
61898     try {
61899       result = Dali::Toolkit::FlexContainer::New();
61900     } catch (std::out_of_range& e) {
61901       {
61902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61903       };
61904     } catch (std::exception& e) {
61905       {
61906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61907       };
61908     } catch (...) {
61909       {
61910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61911       };
61912     }
61913   }
61914   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61915   return jresult;
61916 }
61917
61918
61919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61920   void * jresult ;
61921   Dali::BaseHandle arg1 ;
61922   Dali::BaseHandle *argp1 ;
61923   Dali::Toolkit::FlexContainer result;
61924
61925   argp1 = (Dali::BaseHandle *)jarg1;
61926   if (!argp1) {
61927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61928     return 0;
61929   }
61930   arg1 = *argp1;
61931   {
61932     try {
61933       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61934     } catch (std::out_of_range& e) {
61935       {
61936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61937       };
61938     } catch (std::exception& e) {
61939       {
61940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61941       };
61942     } catch (...) {
61943       {
61944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61945       };
61946     }
61947   }
61948   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61949   return jresult;
61950 }
61951
61952
61953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61954   int jresult ;
61955   int result;
61956
61957   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61958   jresult = (int)result;
61959   return jresult;
61960 }
61961
61962
61963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61964   int jresult ;
61965   int result;
61966
61967   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61968   jresult = (int)result;
61969   return jresult;
61970 }
61971
61972
61973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61974   int jresult ;
61975   int result;
61976
61977   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61978   jresult = (int)result;
61979   return jresult;
61980 }
61981
61982
61983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61984   int jresult ;
61985   int result;
61986
61987   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61988   jresult = (int)result;
61989   return jresult;
61990 }
61991
61992
61993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61994   void * jresult ;
61995   Dali::Toolkit::ImageView::Property *result = 0 ;
61996
61997   {
61998     try {
61999       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
62000     } catch (std::out_of_range& e) {
62001       {
62002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62003       };
62004     } catch (std::exception& e) {
62005       {
62006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62007       };
62008     } catch (...) {
62009       {
62010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62011       };
62012     }
62013   }
62014   jresult = (void *)result;
62015   return jresult;
62016 }
62017
62018
62019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
62020   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
62021
62022   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62023   {
62024     try {
62025       delete arg1;
62026     } catch (std::out_of_range& e) {
62027       {
62028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62029       };
62030     } catch (std::exception& e) {
62031       {
62032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62037       };
62038     }
62039   }
62040 }
62041
62042
62043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62044   void * jresult ;
62045   Dali::Toolkit::ImageView *result = 0 ;
62046
62047   {
62048     try {
62049       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62050     } catch (std::out_of_range& e) {
62051       {
62052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62053       };
62054     } catch (std::exception& e) {
62055       {
62056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62057       };
62058     } catch (...) {
62059       {
62060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62061       };
62062     }
62063   }
62064   jresult = (void *)result;
62065   return jresult;
62066 }
62067
62068
62069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62070   void * jresult ;
62071   Dali::Toolkit::ImageView result;
62072
62073   {
62074     try {
62075       result = Dali::Toolkit::ImageView::New();
62076     } catch (std::out_of_range& e) {
62077       {
62078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62079       };
62080     } catch (std::exception& e) {
62081       {
62082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62083       };
62084     } catch (...) {
62085       {
62086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62087       };
62088     }
62089   }
62090   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62091   return jresult;
62092 }
62093
62094
62095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62096   void * jresult ;
62097   Dali::Image arg1 ;
62098   Dali::Image *argp1 ;
62099   Dali::Toolkit::ImageView result;
62100
62101   argp1 = (Dali::Image *)jarg1;
62102   if (!argp1) {
62103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62104     return 0;
62105   }
62106   arg1 = *argp1;
62107   {
62108     try {
62109       result = Dali::Toolkit::ImageView::New(arg1);
62110     } catch (std::out_of_range& e) {
62111       {
62112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62113       };
62114     } catch (std::exception& e) {
62115       {
62116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62121       };
62122     }
62123   }
62124   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62125   return jresult;
62126 }
62127
62128
62129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62130   void * jresult ;
62131   std::string *arg1 = 0 ;
62132   Dali::Toolkit::ImageView result;
62133
62134   if (!jarg1) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62136     return 0;
62137   }
62138   std::string arg1_str(jarg1);
62139   arg1 = &arg1_str;
62140   {
62141     try {
62142       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62143     } catch (std::out_of_range& e) {
62144       {
62145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (std::exception& e) {
62148       {
62149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (...) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62154       };
62155     }
62156   }
62157   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62158
62159   //argout typemap for const std::string&
62160
62161   return jresult;
62162 }
62163
62164
62165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62166   void * jresult ;
62167   std::string *arg1 = 0 ;
62168   Dali::ImageDimensions arg2 ;
62169   Dali::ImageDimensions *argp2 ;
62170   Dali::Toolkit::ImageView result;
62171
62172   if (!jarg1) {
62173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62174     return 0;
62175   }
62176   std::string arg1_str(jarg1);
62177   arg1 = &arg1_str;
62178   argp2 = (Dali::ImageDimensions *)jarg2;
62179   if (!argp2) {
62180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62181     return 0;
62182   }
62183   arg2 = *argp2;
62184   {
62185     try {
62186       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62187     } catch (std::out_of_range& e) {
62188       {
62189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62190       };
62191     } catch (std::exception& e) {
62192       {
62193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62194       };
62195     } catch (...) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62198       };
62199     }
62200   }
62201   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62202
62203   //argout typemap for const std::string&
62204
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62210   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62211
62212   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62213   {
62214     try {
62215       delete arg1;
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62223       };
62224     } catch (...) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62227       };
62228     }
62229   }
62230 }
62231
62232
62233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62234   void * jresult ;
62235   Dali::Toolkit::ImageView *arg1 = 0 ;
62236   Dali::Toolkit::ImageView *result = 0 ;
62237
62238   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62239   if (!arg1) {
62240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62241     return 0;
62242   }
62243   {
62244     try {
62245       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62253       };
62254     } catch (...) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62257       };
62258     }
62259   }
62260   jresult = (void *)result;
62261   return jresult;
62262 }
62263
62264
62265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62266   void * jresult ;
62267   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62268   Dali::Toolkit::ImageView *arg2 = 0 ;
62269   Dali::Toolkit::ImageView *result = 0 ;
62270
62271   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62272   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62273   if (!arg2) {
62274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62275     return 0;
62276   }
62277   {
62278     try {
62279       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62280     } catch (std::out_of_range& e) {
62281       {
62282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62283       };
62284     } catch (std::exception& e) {
62285       {
62286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62287       };
62288     } catch (...) {
62289       {
62290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62291       };
62292     }
62293   }
62294   jresult = (void *)result;
62295   return jresult;
62296 }
62297
62298
62299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62300   void * jresult ;
62301   Dali::BaseHandle arg1 ;
62302   Dali::BaseHandle *argp1 ;
62303   Dali::Toolkit::ImageView result;
62304
62305   argp1 = (Dali::BaseHandle *)jarg1;
62306   if (!argp1) {
62307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62308     return 0;
62309   }
62310   arg1 = *argp1;
62311   {
62312     try {
62313       result = Dali::Toolkit::ImageView::DownCast(arg1);
62314     } catch (std::out_of_range& e) {
62315       {
62316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62317       };
62318     } catch (std::exception& e) {
62319       {
62320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (...) {
62323       {
62324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62325       };
62326     }
62327   }
62328   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62329   return jresult;
62330 }
62331
62332
62333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62334   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62335   Dali::Image arg2 ;
62336   Dali::Image *argp2 ;
62337
62338   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62339   argp2 = (Dali::Image *)jarg2;
62340   if (!argp2) {
62341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62342     return ;
62343   }
62344   arg2 = *argp2;
62345   {
62346     try {
62347       (arg1)->SetImage(arg2);
62348     } catch (std::out_of_range& e) {
62349       {
62350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62351       };
62352     } catch (std::exception& e) {
62353       {
62354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62355       };
62356     } catch (...) {
62357       {
62358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62359       };
62360     }
62361   }
62362 }
62363
62364
62365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62366   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62367   std::string *arg2 = 0 ;
62368
62369   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62370   if (!jarg2) {
62371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62372     return ;
62373   }
62374   std::string arg2_str(jarg2);
62375   arg2 = &arg2_str;
62376   {
62377     try {
62378       (arg1)->SetImage((std::string const &)*arg2);
62379     } catch (std::out_of_range& e) {
62380       {
62381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62382       };
62383     } catch (std::exception& e) {
62384       {
62385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62386       };
62387     } catch (...) {
62388       {
62389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62390       };
62391     }
62392   }
62393
62394   //argout typemap for const std::string&
62395
62396 }
62397
62398
62399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62400   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62401   std::string *arg2 = 0 ;
62402   Dali::ImageDimensions arg3 ;
62403   Dali::ImageDimensions *argp3 ;
62404
62405   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62406   if (!jarg2) {
62407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62408     return ;
62409   }
62410   std::string arg2_str(jarg2);
62411   arg2 = &arg2_str;
62412   argp3 = (Dali::ImageDimensions *)jarg3;
62413   if (!argp3) {
62414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62415     return ;
62416   }
62417   arg3 = *argp3;
62418   {
62419     try {
62420       (arg1)->SetImage((std::string const &)*arg2,arg3);
62421     } catch (std::out_of_range& e) {
62422       {
62423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62424       };
62425     } catch (std::exception& e) {
62426       {
62427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62428       };
62429     } catch (...) {
62430       {
62431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62432       };
62433     }
62434   }
62435
62436   //argout typemap for const std::string&
62437
62438 }
62439
62440
62441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62442   void * jresult ;
62443   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62444   Dali::Image result;
62445
62446   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62447   {
62448     try {
62449       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62450     } catch (std::out_of_range& e) {
62451       {
62452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62453       };
62454     } catch (std::exception& e) {
62455       {
62456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62457       };
62458     } catch (...) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62461       };
62462     }
62463   }
62464   jresult = new Dali::Image((const Dali::Image &)result);
62465   return jresult;
62466 }
62467
62468
62469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62470   int jresult ;
62471   int result;
62472
62473   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62474   jresult = (int)result;
62475   return jresult;
62476 }
62477
62478
62479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62480   int jresult ;
62481   int result;
62482
62483   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62484   jresult = (int)result;
62485   return jresult;
62486 }
62487
62488
62489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62490   int jresult ;
62491   int result;
62492
62493   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62494   jresult = (int)result;
62495   return jresult;
62496 }
62497
62498
62499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62500   int jresult ;
62501   int result;
62502
62503   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62504   jresult = (int)result;
62505   return jresult;
62506 }
62507
62508
62509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62510   int jresult ;
62511   int result;
62512
62513   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62514   jresult = (int)result;
62515   return jresult;
62516 }
62517
62518
62519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62520   int jresult ;
62521   int result;
62522
62523   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62524   jresult = (int)result;
62525   return jresult;
62526 }
62527
62528
62529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62530   int jresult ;
62531   int result;
62532
62533   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62534   jresult = (int)result;
62535   return jresult;
62536 }
62537
62538
62539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62540   int jresult ;
62541   int result;
62542
62543   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62544   jresult = (int)result;
62545   return jresult;
62546 }
62547
62548
62549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62550   void * jresult ;
62551   Dali::Toolkit::Model3dView::Property *result = 0 ;
62552
62553   {
62554     try {
62555       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62556     } catch (std::out_of_range& e) {
62557       {
62558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62559       };
62560     } catch (std::exception& e) {
62561       {
62562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62563       };
62564     } catch (...) {
62565       {
62566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62567       };
62568     }
62569   }
62570   jresult = (void *)result;
62571   return jresult;
62572 }
62573
62574
62575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62576   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62577
62578   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62579   {
62580     try {
62581       delete arg1;
62582     } catch (std::out_of_range& e) {
62583       {
62584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62585       };
62586     } catch (std::exception& e) {
62587       {
62588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62589       };
62590     } catch (...) {
62591       {
62592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62593       };
62594     }
62595   }
62596 }
62597
62598
62599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62600   void * jresult ;
62601   Dali::Toolkit::Model3dView result;
62602
62603   {
62604     try {
62605       result = Dali::Toolkit::Model3dView::New();
62606     } catch (std::out_of_range& e) {
62607       {
62608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (std::exception& e) {
62611       {
62612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (...) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62617       };
62618     }
62619   }
62620   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62621   return jresult;
62622 }
62623
62624
62625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62626   void * jresult ;
62627   std::string *arg1 = 0 ;
62628   std::string *arg2 = 0 ;
62629   std::string *arg3 = 0 ;
62630   Dali::Toolkit::Model3dView result;
62631
62632   if (!jarg1) {
62633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62634     return 0;
62635   }
62636   std::string arg1_str(jarg1);
62637   arg1 = &arg1_str;
62638   if (!jarg2) {
62639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62640     return 0;
62641   }
62642   std::string arg2_str(jarg2);
62643   arg2 = &arg2_str;
62644   if (!jarg3) {
62645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62646     return 0;
62647   }
62648   std::string arg3_str(jarg3);
62649   arg3 = &arg3_str;
62650   {
62651     try {
62652       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62653     } catch (std::out_of_range& e) {
62654       {
62655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62656       };
62657     } catch (std::exception& e) {
62658       {
62659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62660       };
62661     } catch (...) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62664       };
62665     }
62666   }
62667   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62668
62669   //argout typemap for const std::string&
62670
62671
62672   //argout typemap for const std::string&
62673
62674
62675   //argout typemap for const std::string&
62676
62677   return jresult;
62678 }
62679
62680
62681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62682   void * jresult ;
62683   Dali::Toolkit::Model3dView *result = 0 ;
62684
62685   {
62686     try {
62687       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (...) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62699       };
62700     }
62701   }
62702   jresult = (void *)result;
62703   return jresult;
62704 }
62705
62706
62707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62708   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62709
62710   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62711   {
62712     try {
62713       delete arg1;
62714     } catch (std::out_of_range& e) {
62715       {
62716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62717       };
62718     } catch (std::exception& e) {
62719       {
62720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62721       };
62722     } catch (...) {
62723       {
62724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62725       };
62726     }
62727   }
62728 }
62729
62730
62731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62732   void * jresult ;
62733   Dali::Toolkit::Model3dView *arg1 = 0 ;
62734   Dali::Toolkit::Model3dView *result = 0 ;
62735
62736   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62737   if (!arg1) {
62738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62739     return 0;
62740   }
62741   {
62742     try {
62743       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62744     } catch (std::out_of_range& e) {
62745       {
62746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62747       };
62748     } catch (std::exception& e) {
62749       {
62750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62751       };
62752     } catch (...) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62755       };
62756     }
62757   }
62758   jresult = (void *)result;
62759   return jresult;
62760 }
62761
62762
62763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62764   void * jresult ;
62765   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62766   Dali::Toolkit::Model3dView *arg2 = 0 ;
62767   Dali::Toolkit::Model3dView *result = 0 ;
62768
62769   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62770   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62771   if (!arg2) {
62772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62773     return 0;
62774   }
62775   {
62776     try {
62777       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62778     } catch (std::out_of_range& e) {
62779       {
62780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62781       };
62782     } catch (std::exception& e) {
62783       {
62784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62785       };
62786     } catch (...) {
62787       {
62788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62789       };
62790     }
62791   }
62792   jresult = (void *)result;
62793   return jresult;
62794 }
62795
62796
62797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62798   void * jresult ;
62799   Dali::BaseHandle arg1 ;
62800   Dali::BaseHandle *argp1 ;
62801   Dali::Toolkit::Model3dView result;
62802
62803   argp1 = (Dali::BaseHandle *)jarg1;
62804   if (!argp1) {
62805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62806     return 0;
62807   }
62808   arg1 = *argp1;
62809   {
62810     try {
62811       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62812     } catch (std::out_of_range& e) {
62813       {
62814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62815       };
62816     } catch (std::exception& e) {
62817       {
62818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62819       };
62820     } catch (...) {
62821       {
62822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62823       };
62824     }
62825   }
62826   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62827   return jresult;
62828 }
62829
62830
62831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62832   int jresult ;
62833   int result;
62834
62835   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62836   jresult = (int)result;
62837   return jresult;
62838 }
62839
62840
62841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62842   int jresult ;
62843   int result;
62844
62845   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62846   jresult = (int)result;
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62852   int jresult ;
62853   int result;
62854
62855   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62856   jresult = (int)result;
62857   return jresult;
62858 }
62859
62860
62861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62862   int jresult ;
62863   int result;
62864
62865   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62866   jresult = (int)result;
62867   return jresult;
62868 }
62869
62870
62871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62872   int jresult ;
62873   int result;
62874
62875   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62876   jresult = (int)result;
62877   return jresult;
62878 }
62879
62880
62881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62882   int jresult ;
62883   int result;
62884
62885   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62886   jresult = (int)result;
62887   return jresult;
62888 }
62889
62890
62891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62892   int jresult ;
62893   int result;
62894
62895   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62896   jresult = (int)result;
62897   return jresult;
62898 }
62899
62900
62901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62902   int jresult ;
62903   int result;
62904
62905   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62906   jresult = (int)result;
62907   return jresult;
62908 }
62909
62910
62911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62912   int jresult ;
62913   int result;
62914
62915   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62916   jresult = (int)result;
62917   return jresult;
62918 }
62919
62920
62921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62922   void * jresult ;
62923   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62924
62925   {
62926     try {
62927       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
62928     } catch (std::out_of_range& e) {
62929       {
62930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62931       };
62932     } catch (std::exception& e) {
62933       {
62934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (...) {
62937       {
62938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62939       };
62940     }
62941   }
62942   jresult = (void *)result;
62943   return jresult;
62944 }
62945
62946
62947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
62948   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62949
62950   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62951   {
62952     try {
62953       delete arg1;
62954     } catch (std::out_of_range& e) {
62955       {
62956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62957       };
62958     } catch (std::exception& e) {
62959       {
62960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62961       };
62962     } catch (...) {
62963       {
62964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62965       };
62966     }
62967   }
62968 }
62969
62970
62971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62972   void * jresult ;
62973   Dali::Toolkit::ScrollBar *result = 0 ;
62974
62975   {
62976     try {
62977       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62978     } catch (std::out_of_range& e) {
62979       {
62980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (std::exception& e) {
62983       {
62984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62985       };
62986     } catch (...) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62989       };
62990     }
62991   }
62992   jresult = (void *)result;
62993   return jresult;
62994 }
62995
62996
62997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62998   void * jresult ;
62999   Dali::Toolkit::ScrollBar *arg1 = 0 ;
63000   Dali::Toolkit::ScrollBar *result = 0 ;
63001
63002   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63003   if (!arg1) {
63004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63005     return 0;
63006   }
63007   {
63008     try {
63009       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
63010     } catch (std::out_of_range& e) {
63011       {
63012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63013       };
63014     } catch (std::exception& e) {
63015       {
63016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63017       };
63018     } catch (...) {
63019       {
63020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63021       };
63022     }
63023   }
63024   jresult = (void *)result;
63025   return jresult;
63026 }
63027
63028
63029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63030   void * jresult ;
63031   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63032   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63033   Dali::Toolkit::ScrollBar *result = 0 ;
63034
63035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63036   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63037   if (!arg2) {
63038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63039     return 0;
63040   }
63041   {
63042     try {
63043       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63044     } catch (std::out_of_range& e) {
63045       {
63046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63047       };
63048     } catch (std::exception& e) {
63049       {
63050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63051       };
63052     } catch (...) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63055       };
63056     }
63057   }
63058   jresult = (void *)result;
63059   return jresult;
63060 }
63061
63062
63063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63064   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63065
63066   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63067   {
63068     try {
63069       delete arg1;
63070     } catch (std::out_of_range& e) {
63071       {
63072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63073       };
63074     } catch (std::exception& e) {
63075       {
63076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63077       };
63078     } catch (...) {
63079       {
63080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63081       };
63082     }
63083   }
63084 }
63085
63086
63087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63088   void * jresult ;
63089   Dali::Toolkit::ScrollBar::Direction arg1 ;
63090   Dali::Toolkit::ScrollBar result;
63091
63092   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63093   {
63094     try {
63095       result = Dali::Toolkit::ScrollBar::New(arg1);
63096     } catch (std::out_of_range& e) {
63097       {
63098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63099       };
63100     } catch (std::exception& e) {
63101       {
63102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63103       };
63104     } catch (...) {
63105       {
63106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63107       };
63108     }
63109   }
63110   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63111   return jresult;
63112 }
63113
63114
63115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63116   void * jresult ;
63117   Dali::Toolkit::ScrollBar result;
63118
63119   {
63120     try {
63121       result = Dali::Toolkit::ScrollBar::New();
63122     } catch (std::out_of_range& e) {
63123       {
63124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63125       };
63126     } catch (std::exception& e) {
63127       {
63128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63129       };
63130     } catch (...) {
63131       {
63132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63133       };
63134     }
63135   }
63136   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63137   return jresult;
63138 }
63139
63140
63141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63142   void * jresult ;
63143   Dali::BaseHandle arg1 ;
63144   Dali::BaseHandle *argp1 ;
63145   Dali::Toolkit::ScrollBar result;
63146
63147   argp1 = (Dali::BaseHandle *)jarg1;
63148   if (!argp1) {
63149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63150     return 0;
63151   }
63152   arg1 = *argp1;
63153   {
63154     try {
63155       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63163       };
63164     } catch (...) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63167       };
63168     }
63169   }
63170   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63171   return jresult;
63172 }
63173
63174
63175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63176   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63177   Dali::Handle arg2 ;
63178   Dali::Property::Index arg3 ;
63179   Dali::Property::Index arg4 ;
63180   Dali::Property::Index arg5 ;
63181   Dali::Property::Index arg6 ;
63182   Dali::Handle *argp2 ;
63183
63184   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63185   argp2 = (Dali::Handle *)jarg2;
63186   if (!argp2) {
63187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63188     return ;
63189   }
63190   arg2 = *argp2;
63191   arg3 = (Dali::Property::Index)jarg3;
63192   arg4 = (Dali::Property::Index)jarg4;
63193   arg5 = (Dali::Property::Index)jarg5;
63194   arg6 = (Dali::Property::Index)jarg6;
63195   {
63196     try {
63197       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63198     } catch (std::out_of_range& e) {
63199       {
63200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63201       };
63202     } catch (std::exception& e) {
63203       {
63204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63205       };
63206     } catch (...) {
63207       {
63208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63209       };
63210     }
63211   }
63212 }
63213
63214
63215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63217   Dali::Actor arg2 ;
63218   Dali::Actor *argp2 ;
63219
63220   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63221   argp2 = (Dali::Actor *)jarg2;
63222   if (!argp2) {
63223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63224     return ;
63225   }
63226   arg2 = *argp2;
63227   {
63228     try {
63229       (arg1)->SetScrollIndicator(arg2);
63230     } catch (std::out_of_range& e) {
63231       {
63232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63233       };
63234     } catch (std::exception& e) {
63235       {
63236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63237       };
63238     } catch (...) {
63239       {
63240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63241       };
63242     }
63243   }
63244 }
63245
63246
63247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63248   void * jresult ;
63249   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63250   Dali::Actor result;
63251
63252   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63253   {
63254     try {
63255       result = (arg1)->GetScrollIndicator();
63256     } catch (std::out_of_range& e) {
63257       {
63258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63259       };
63260     } catch (std::exception& e) {
63261       {
63262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (...) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63267       };
63268     }
63269   }
63270   jresult = new Dali::Actor((const Dali::Actor &)result);
63271   return jresult;
63272 }
63273
63274
63275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63276   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63277   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63278
63279   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63280   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63281   if (!arg2) {
63282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63283     return ;
63284   }
63285   {
63286     try {
63287       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63288     } catch (std::out_of_range& e) {
63289       {
63290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63291       };
63292     } catch (std::exception& e) {
63293       {
63294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63295       };
63296     } catch (...) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63299       };
63300     }
63301   }
63302 }
63303
63304
63305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63306   void * jresult ;
63307   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63308   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63309
63310   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63311   {
63312     try {
63313       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63314     } catch (std::out_of_range& e) {
63315       {
63316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (std::exception& e) {
63319       {
63320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63329   return jresult;
63330 }
63331
63332
63333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63334   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63335   Dali::Toolkit::ScrollBar::Direction arg2 ;
63336
63337   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63338   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63339   {
63340     try {
63341       (arg1)->SetScrollDirection(arg2);
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63349       };
63350     } catch (...) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63353       };
63354     }
63355   }
63356 }
63357
63358
63359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63360   int jresult ;
63361   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63362   Dali::Toolkit::ScrollBar::Direction result;
63363
63364   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63365   {
63366     try {
63367       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63368     } catch (std::out_of_range& e) {
63369       {
63370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63371       };
63372     } catch (std::exception& e) {
63373       {
63374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63375       };
63376     } catch (...) {
63377       {
63378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63379       };
63380     }
63381   }
63382   jresult = (int)result;
63383   return jresult;
63384 }
63385
63386
63387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63388   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63389   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63390
63391   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63392   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63393   {
63394     try {
63395       (arg1)->SetIndicatorHeightPolicy(arg2);
63396     } catch (std::out_of_range& e) {
63397       {
63398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63399       };
63400     } catch (std::exception& e) {
63401       {
63402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63403       };
63404     } catch (...) {
63405       {
63406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63407       };
63408     }
63409   }
63410 }
63411
63412
63413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63414   int jresult ;
63415   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63416   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63417
63418   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63419   {
63420     try {
63421       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63422     } catch (std::out_of_range& e) {
63423       {
63424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63425       };
63426     } catch (std::exception& e) {
63427       {
63428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63429       };
63430     } catch (...) {
63431       {
63432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63433       };
63434     }
63435   }
63436   jresult = (int)result;
63437   return jresult;
63438 }
63439
63440
63441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63442   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63443   float arg2 ;
63444
63445   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63446   arg2 = (float)jarg2;
63447   {
63448     try {
63449       (arg1)->SetIndicatorFixedHeight(arg2);
63450     } catch (std::out_of_range& e) {
63451       {
63452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63453       };
63454     } catch (std::exception& e) {
63455       {
63456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63457       };
63458     } catch (...) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63461       };
63462     }
63463   }
63464 }
63465
63466
63467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63468   float jresult ;
63469   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63470   float result;
63471
63472   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63473   {
63474     try {
63475       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63476     } catch (std::out_of_range& e) {
63477       {
63478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63479       };
63480     } catch (std::exception& e) {
63481       {
63482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63483       };
63484     } catch (...) {
63485       {
63486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63487       };
63488     }
63489   }
63490   jresult = result;
63491   return jresult;
63492 }
63493
63494
63495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63496   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63497   float arg2 ;
63498
63499   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63500   arg2 = (float)jarg2;
63501   {
63502     try {
63503       (arg1)->SetIndicatorShowDuration(arg2);
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63511       };
63512     } catch (...) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63515       };
63516     }
63517   }
63518 }
63519
63520
63521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63522   float jresult ;
63523   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63524   float result;
63525
63526   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63527   {
63528     try {
63529       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63530     } catch (std::out_of_range& e) {
63531       {
63532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63533       };
63534     } catch (std::exception& e) {
63535       {
63536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63537       };
63538     } catch (...) {
63539       {
63540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63541       };
63542     }
63543   }
63544   jresult = result;
63545   return jresult;
63546 }
63547
63548
63549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63550   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63551   float arg2 ;
63552
63553   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63554   arg2 = (float)jarg2;
63555   {
63556     try {
63557       (arg1)->SetIndicatorHideDuration(arg2);
63558     } catch (std::out_of_range& e) {
63559       {
63560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63561       };
63562     } catch (std::exception& e) {
63563       {
63564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63565       };
63566     } catch (...) {
63567       {
63568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63569       };
63570     }
63571   }
63572 }
63573
63574
63575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63576   float jresult ;
63577   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63578   float result;
63579
63580   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63581   {
63582     try {
63583       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63591       };
63592     } catch (...) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63595       };
63596     }
63597   }
63598   jresult = result;
63599   return jresult;
63600 }
63601
63602
63603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63604   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63605
63606   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63607   {
63608     try {
63609       (arg1)->ShowIndicator();
63610     } catch (std::out_of_range& e) {
63611       {
63612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63613       };
63614     } catch (std::exception& e) {
63615       {
63616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63621       };
63622     }
63623   }
63624 }
63625
63626
63627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63629
63630   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63631   {
63632     try {
63633       (arg1)->HideIndicator();
63634     } catch (std::out_of_range& e) {
63635       {
63636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63637       };
63638     } catch (std::exception& e) {
63639       {
63640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63641       };
63642     } catch (...) {
63643       {
63644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63645       };
63646     }
63647   }
63648 }
63649
63650
63651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63652   void * jresult ;
63653   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63654   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63655
63656   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63657   {
63658     try {
63659       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63660     } catch (std::out_of_range& e) {
63661       {
63662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (std::exception& e) {
63665       {
63666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674   jresult = (void *)result;
63675   return jresult;
63676 }
63677
63678
63679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63680   void * jresult ;
63681   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63682   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63683
63684   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63685   {
63686     try {
63687       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63688     } catch (std::out_of_range& e) {
63689       {
63690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63691       };
63692     } catch (std::exception& e) {
63693       {
63694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63695       };
63696     } catch (...) {
63697       {
63698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63699       };
63700     }
63701   }
63702   jresult = (void *)result;
63703   return jresult;
63704 }
63705
63706
63707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63708   int jresult ;
63709   int result;
63710
63711   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63712   jresult = (int)result;
63713   return jresult;
63714 }
63715
63716
63717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63718   int jresult ;
63719   int result;
63720
63721   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63722   jresult = (int)result;
63723   return jresult;
63724 }
63725
63726
63727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63728   int jresult ;
63729   int result;
63730
63731   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63732   jresult = (int)result;
63733   return jresult;
63734 }
63735
63736
63737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63738   int jresult ;
63739   int result;
63740
63741   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63742   jresult = (int)result;
63743   return jresult;
63744 }
63745
63746
63747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63748   int jresult ;
63749   int result;
63750
63751   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63752   jresult = (int)result;
63753   return jresult;
63754 }
63755
63756
63757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63758   int jresult ;
63759   int result;
63760
63761   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63762   jresult = (int)result;
63763   return jresult;
63764 }
63765
63766
63767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63768   int jresult ;
63769   int result;
63770
63771   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63772   jresult = (int)result;
63773   return jresult;
63774 }
63775
63776
63777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63778   int jresult ;
63779   int result;
63780
63781   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63782   jresult = (int)result;
63783   return jresult;
63784 }
63785
63786
63787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63788   int jresult ;
63789   int result;
63790
63791   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63792   jresult = (int)result;
63793   return jresult;
63794 }
63795
63796
63797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63798   int jresult ;
63799   int result;
63800
63801   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63802   jresult = (int)result;
63803   return jresult;
63804 }
63805
63806
63807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63808   int jresult ;
63809   int result;
63810
63811   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63812   jresult = (int)result;
63813   return jresult;
63814 }
63815
63816
63817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63818   int jresult ;
63819   int result;
63820
63821   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63822   jresult = (int)result;
63823   return jresult;
63824 }
63825
63826
63827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63828   int jresult ;
63829   int result;
63830
63831   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63832   jresult = (int)result;
63833   return jresult;
63834 }
63835
63836
63837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63838   int jresult ;
63839   int result;
63840
63841   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63842   jresult = (int)result;
63843   return jresult;
63844 }
63845
63846
63847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63848   void * jresult ;
63849   Dali::Toolkit::Scrollable::Property *result = 0 ;
63850
63851   {
63852     try {
63853       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63854     } catch (std::out_of_range& e) {
63855       {
63856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63857       };
63858     } catch (std::exception& e) {
63859       {
63860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63861       };
63862     } catch (...) {
63863       {
63864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63865       };
63866     }
63867   }
63868   jresult = (void *)result;
63869   return jresult;
63870 }
63871
63872
63873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63874   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63875
63876   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63877   {
63878     try {
63879       delete arg1;
63880     } catch (std::out_of_range& e) {
63881       {
63882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63883       };
63884     } catch (std::exception& e) {
63885       {
63886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (...) {
63889       {
63890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63891       };
63892     }
63893   }
63894 }
63895
63896
63897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63898   void * jresult ;
63899   Dali::Toolkit::Scrollable *result = 0 ;
63900
63901   {
63902     try {
63903       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63904     } catch (std::out_of_range& e) {
63905       {
63906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (std::exception& e) {
63909       {
63910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63911       };
63912     } catch (...) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63915       };
63916     }
63917   }
63918   jresult = (void *)result;
63919   return jresult;
63920 }
63921
63922
63923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63924   void * jresult ;
63925   Dali::Toolkit::Scrollable *arg1 = 0 ;
63926   Dali::Toolkit::Scrollable *result = 0 ;
63927
63928   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63929   if (!arg1) {
63930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63931     return 0;
63932   }
63933   {
63934     try {
63935       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63936     } catch (std::out_of_range& e) {
63937       {
63938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63939       };
63940     } catch (std::exception& e) {
63941       {
63942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63943       };
63944     } catch (...) {
63945       {
63946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63947       };
63948     }
63949   }
63950   jresult = (void *)result;
63951   return jresult;
63952 }
63953
63954
63955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63956   void * jresult ;
63957   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63958   Dali::Toolkit::Scrollable *arg2 = 0 ;
63959   Dali::Toolkit::Scrollable *result = 0 ;
63960
63961   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63962   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63963   if (!arg2) {
63964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63965     return 0;
63966   }
63967   {
63968     try {
63969       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63970     } catch (std::out_of_range& e) {
63971       {
63972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63973       };
63974     } catch (std::exception& e) {
63975       {
63976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63977       };
63978     } catch (...) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63981       };
63982     }
63983   }
63984   jresult = (void *)result;
63985   return jresult;
63986 }
63987
63988
63989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63990   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63991
63992   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63993   {
63994     try {
63995       delete arg1;
63996     } catch (std::out_of_range& e) {
63997       {
63998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63999       };
64000     } catch (std::exception& e) {
64001       {
64002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64003       };
64004     } catch (...) {
64005       {
64006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64007       };
64008     }
64009   }
64010 }
64011
64012
64013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
64014   void * jresult ;
64015   Dali::BaseHandle arg1 ;
64016   Dali::BaseHandle *argp1 ;
64017   Dali::Toolkit::Scrollable result;
64018
64019   argp1 = (Dali::BaseHandle *)jarg1;
64020   if (!argp1) {
64021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64022     return 0;
64023   }
64024   arg1 = *argp1;
64025   {
64026     try {
64027       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64028     } catch (std::out_of_range& e) {
64029       {
64030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64031       };
64032     } catch (std::exception& e) {
64033       {
64034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64035       };
64036     } catch (...) {
64037       {
64038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64039       };
64040     }
64041   }
64042   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64043   return jresult;
64044 }
64045
64046
64047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64048   unsigned int jresult ;
64049   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64050   bool result;
64051
64052   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64053   {
64054     try {
64055       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64056     } catch (std::out_of_range& e) {
64057       {
64058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64059       };
64060     } catch (std::exception& e) {
64061       {
64062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64063       };
64064     } catch (...) {
64065       {
64066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64067       };
64068     }
64069   }
64070   jresult = result;
64071   return jresult;
64072 }
64073
64074
64075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64076   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64077   bool arg2 ;
64078
64079   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64080   arg2 = jarg2 ? true : false;
64081   {
64082     try {
64083       (arg1)->SetOvershootEnabled(arg2);
64084     } catch (std::out_of_range& e) {
64085       {
64086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64087       };
64088     } catch (std::exception& e) {
64089       {
64090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (...) {
64093       {
64094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64095       };
64096     }
64097   }
64098 }
64099
64100
64101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64102   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64103   Dali::Vector4 *arg2 = 0 ;
64104
64105   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64106   arg2 = (Dali::Vector4 *)jarg2;
64107   if (!arg2) {
64108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64109     return ;
64110   }
64111   {
64112     try {
64113       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64114     } catch (std::out_of_range& e) {
64115       {
64116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64117       };
64118     } catch (std::exception& e) {
64119       {
64120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64121       };
64122     } catch (...) {
64123       {
64124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64125       };
64126     }
64127   }
64128 }
64129
64130
64131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64132   void * jresult ;
64133   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64134   Dali::Vector4 result;
64135
64136   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64137   {
64138     try {
64139       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64140     } catch (std::out_of_range& e) {
64141       {
64142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64143       };
64144     } catch (std::exception& e) {
64145       {
64146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64147       };
64148     } catch (...) {
64149       {
64150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64151       };
64152     }
64153   }
64154   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64155   return jresult;
64156 }
64157
64158
64159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64160   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64161   float arg2 ;
64162
64163   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64164   arg2 = (float)jarg2;
64165   {
64166     try {
64167       (arg1)->SetOvershootAnimationSpeed(arg2);
64168     } catch (std::out_of_range& e) {
64169       {
64170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64171       };
64172     } catch (std::exception& e) {
64173       {
64174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64175       };
64176     } catch (...) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64179       };
64180     }
64181   }
64182 }
64183
64184
64185 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64186   float jresult ;
64187   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64188   float result;
64189
64190   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64191   {
64192     try {
64193       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64194     } catch (std::out_of_range& e) {
64195       {
64196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64197       };
64198     } catch (std::exception& e) {
64199       {
64200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64201       };
64202     } catch (...) {
64203       {
64204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64205       };
64206     }
64207   }
64208   jresult = result;
64209   return jresult;
64210 }
64211
64212
64213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64214   void * jresult ;
64215   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64216   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64217
64218   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64219   {
64220     try {
64221       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64222     } catch (std::out_of_range& e) {
64223       {
64224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64225       };
64226     } catch (std::exception& e) {
64227       {
64228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64229       };
64230     } catch (...) {
64231       {
64232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64233       };
64234     }
64235   }
64236   jresult = (void *)result;
64237   return jresult;
64238 }
64239
64240
64241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64242   void * jresult ;
64243   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64244   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64245
64246   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64247   {
64248     try {
64249       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64250     } catch (std::out_of_range& e) {
64251       {
64252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64253       };
64254     } catch (std::exception& e) {
64255       {
64256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64257       };
64258     } catch (...) {
64259       {
64260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64261       };
64262     }
64263   }
64264   jresult = (void *)result;
64265   return jresult;
64266 }
64267
64268
64269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64270   void * jresult ;
64271   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64272   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64273
64274   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64275   {
64276     try {
64277       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64278     } catch (std::out_of_range& e) {
64279       {
64280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64281       };
64282     } catch (std::exception& e) {
64283       {
64284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64285       };
64286     } catch (...) {
64287       {
64288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64289       };
64290     }
64291   }
64292   jresult = (void *)result;
64293   return jresult;
64294 }
64295
64296
64297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64298   unsigned int jresult ;
64299   Dali::Toolkit::ControlOrientation::Type arg1 ;
64300   bool result;
64301
64302   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64303   {
64304     try {
64305       result = (bool)Dali::Toolkit::IsVertical(arg1);
64306     } catch (std::out_of_range& e) {
64307       {
64308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64309       };
64310     } catch (std::exception& e) {
64311       {
64312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64313       };
64314     } catch (...) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64317       };
64318     }
64319   }
64320   jresult = result;
64321   return jresult;
64322 }
64323
64324
64325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64326   unsigned int jresult ;
64327   Dali::Toolkit::ControlOrientation::Type arg1 ;
64328   bool result;
64329
64330   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64331   {
64332     try {
64333       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64334     } catch (std::out_of_range& e) {
64335       {
64336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64337       };
64338     } catch (std::exception& e) {
64339       {
64340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64341       };
64342     } catch (...) {
64343       {
64344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64345       };
64346     }
64347   }
64348   jresult = result;
64349   return jresult;
64350 }
64351
64352
64353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64354   void * jresult ;
64355   unsigned int arg1 ;
64356   unsigned int arg2 ;
64357   Dali::Toolkit::ItemRange *result = 0 ;
64358
64359   arg1 = (unsigned int)jarg1;
64360   arg2 = (unsigned int)jarg2;
64361   {
64362     try {
64363       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64364     } catch (std::out_of_range& e) {
64365       {
64366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64367       };
64368     } catch (std::exception& e) {
64369       {
64370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (...) {
64373       {
64374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64375       };
64376     }
64377   }
64378   jresult = (void *)result;
64379   return jresult;
64380 }
64381
64382
64383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64384   void * jresult ;
64385   Dali::Toolkit::ItemRange *arg1 = 0 ;
64386   Dali::Toolkit::ItemRange *result = 0 ;
64387
64388   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64389   if (!arg1) {
64390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64391     return 0;
64392   }
64393   {
64394     try {
64395       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64396     } catch (std::out_of_range& e) {
64397       {
64398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64399       };
64400     } catch (std::exception& e) {
64401       {
64402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64403       };
64404     } catch (...) {
64405       {
64406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64407       };
64408     }
64409   }
64410   jresult = (void *)result;
64411   return jresult;
64412 }
64413
64414
64415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64416   void * jresult ;
64417   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64418   Dali::Toolkit::ItemRange *arg2 = 0 ;
64419   Dali::Toolkit::ItemRange *result = 0 ;
64420
64421   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64422   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64423   if (!arg2) {
64424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64425     return 0;
64426   }
64427   {
64428     try {
64429       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64430     } catch (std::out_of_range& e) {
64431       {
64432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64433       };
64434     } catch (std::exception& e) {
64435       {
64436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64437       };
64438     } catch (...) {
64439       {
64440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64441       };
64442     }
64443   }
64444   jresult = (void *)result;
64445   return jresult;
64446 }
64447
64448
64449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64450   unsigned int jresult ;
64451   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64452   unsigned int arg2 ;
64453   bool result;
64454
64455   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64456   arg2 = (unsigned int)jarg2;
64457   {
64458     try {
64459       result = (bool)(arg1)->Within(arg2);
64460     } catch (std::out_of_range& e) {
64461       {
64462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64463       };
64464     } catch (std::exception& e) {
64465       {
64466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64467       };
64468     } catch (...) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64471       };
64472     }
64473   }
64474   jresult = result;
64475   return jresult;
64476 }
64477
64478
64479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64480   void * jresult ;
64481   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64482   Dali::Toolkit::ItemRange *arg2 = 0 ;
64483   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64484
64485   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64486   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64487   if (!arg2) {
64488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64489     return 0;
64490   }
64491   {
64492     try {
64493       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64494     } catch (std::out_of_range& e) {
64495       {
64496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64497       };
64498     } catch (std::exception& e) {
64499       {
64500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64501       };
64502     } catch (...) {
64503       {
64504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64505       };
64506     }
64507   }
64508   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64509   return jresult;
64510 }
64511
64512
64513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64514   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64515   unsigned int arg2 ;
64516
64517   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64518   arg2 = (unsigned int)jarg2;
64519   if (arg1) (arg1)->begin = arg2;
64520 }
64521
64522
64523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64524   unsigned int jresult ;
64525   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64526   unsigned int result;
64527
64528   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64529   result = (unsigned int) ((arg1)->begin);
64530   jresult = result;
64531   return jresult;
64532 }
64533
64534
64535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64536   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64537   unsigned int arg2 ;
64538
64539   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64540   arg2 = (unsigned int)jarg2;
64541   if (arg1) (arg1)->end = arg2;
64542 }
64543
64544
64545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64546   unsigned int jresult ;
64547   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64548   unsigned int result;
64549
64550   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64551   result = (unsigned int) ((arg1)->end);
64552   jresult = result;
64553   return jresult;
64554 }
64555
64556
64557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64558   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64559
64560   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64561   {
64562     try {
64563       delete arg1;
64564     } catch (std::out_of_range& e) {
64565       {
64566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64567       };
64568     } catch (std::exception& e) {
64569       {
64570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64571       };
64572     } catch (...) {
64573       {
64574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64575       };
64576     }
64577   }
64578 }
64579
64580
64581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64582   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64583
64584   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64585   {
64586     try {
64587       delete arg1;
64588     } catch (std::out_of_range& e) {
64589       {
64590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64591       };
64592     } catch (std::exception& e) {
64593       {
64594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64595       };
64596     } catch (...) {
64597       {
64598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64599       };
64600     }
64601   }
64602 }
64603
64604
64605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64606   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64607   Dali::Toolkit::ControlOrientation::Type arg2 ;
64608
64609   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64610   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64611   {
64612     try {
64613       (arg1)->SetOrientation(arg2);
64614     } catch (std::out_of_range& e) {
64615       {
64616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64617       };
64618     } catch (std::exception& e) {
64619       {
64620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64621       };
64622     } catch (...) {
64623       {
64624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64625       };
64626     }
64627   }
64628 }
64629
64630
64631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64632   int jresult ;
64633   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64634   Dali::Toolkit::ControlOrientation::Type result;
64635
64636   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64637   {
64638     try {
64639       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64640     } catch (std::out_of_range& e) {
64641       {
64642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64643       };
64644     } catch (std::exception& e) {
64645       {
64646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (...) {
64649       {
64650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64651       };
64652     }
64653   }
64654   jresult = (int)result;
64655   return jresult;
64656 }
64657
64658
64659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64660   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64661   Dali::Property::Map *arg2 = 0 ;
64662
64663   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64664   arg2 = (Dali::Property::Map *)jarg2;
64665   if (!arg2) {
64666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64667     return ;
64668   }
64669   {
64670     try {
64671       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64672     } catch (std::out_of_range& e) {
64673       {
64674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64675       };
64676     } catch (std::exception& e) {
64677       {
64678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64679       };
64680     } catch (...) {
64681       {
64682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64683       };
64684     }
64685   }
64686 }
64687
64688
64689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64690   void * jresult ;
64691   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64692   Dali::Property::Map result;
64693
64694   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64695   {
64696     try {
64697       result = (arg1)->GetLayoutProperties();
64698     } catch (std::out_of_range& e) {
64699       {
64700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64701       };
64702     } catch (std::exception& e) {
64703       {
64704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64705       };
64706     } catch (...) {
64707       {
64708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64709       };
64710     }
64711   }
64712   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64713   return jresult;
64714 }
64715
64716
64717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64718   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64719   unsigned int arg2 ;
64720   Dali::Vector3 *arg3 = 0 ;
64721   Dali::Vector3 *arg4 = 0 ;
64722
64723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64724   arg2 = (unsigned int)jarg2;
64725   arg3 = (Dali::Vector3 *)jarg3;
64726   if (!arg3) {
64727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64728     return ;
64729   }
64730   arg4 = (Dali::Vector3 *)jarg4;
64731   if (!arg4) {
64732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64733     return ;
64734   }
64735   {
64736     try {
64737       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64738     } catch (std::out_of_range& e) {
64739       {
64740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64741       };
64742     } catch (std::exception& e) {
64743       {
64744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64745       };
64746     } catch (...) {
64747       {
64748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64749       };
64750     }
64751   }
64752 }
64753
64754
64755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64757   Dali::Vector3 *arg2 = 0 ;
64758
64759   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64760   arg2 = (Dali::Vector3 *)jarg2;
64761   if (!arg2) {
64762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64763     return ;
64764   }
64765   {
64766     try {
64767       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64768     } catch (std::out_of_range& e) {
64769       {
64770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64771       };
64772     } catch (std::exception& e) {
64773       {
64774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64775       };
64776     } catch (...) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64779       };
64780     }
64781   }
64782 }
64783
64784
64785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64786   float jresult ;
64787   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64788   unsigned int arg2 ;
64789   Dali::Vector3 arg3 ;
64790   Dali::Vector3 *argp3 ;
64791   float result;
64792
64793   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64794   arg2 = (unsigned int)jarg2;
64795   argp3 = (Dali::Vector3 *)jarg3;
64796   if (!argp3) {
64797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64798     return 0;
64799   }
64800   arg3 = *argp3;
64801   {
64802     try {
64803       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64804     } catch (std::out_of_range& e) {
64805       {
64806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64807       };
64808     } catch (std::exception& e) {
64809       {
64810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64811       };
64812     } catch (...) {
64813       {
64814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64815       };
64816     }
64817   }
64818   jresult = result;
64819   return jresult;
64820 }
64821
64822
64823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64824   float jresult ;
64825   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64826   float arg2 ;
64827   float result;
64828
64829   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64830   arg2 = (float)jarg2;
64831   {
64832     try {
64833       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64834     } catch (std::out_of_range& e) {
64835       {
64836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64837       };
64838     } catch (std::exception& e) {
64839       {
64840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64841       };
64842     } catch (...) {
64843       {
64844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64845       };
64846     }
64847   }
64848   jresult = result;
64849   return jresult;
64850 }
64851
64852
64853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64854   float jresult ;
64855   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64856   unsigned int arg2 ;
64857   float result;
64858
64859   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64860   arg2 = (unsigned int)jarg2;
64861   {
64862     try {
64863       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64864     } catch (std::out_of_range& e) {
64865       {
64866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64867       };
64868     } catch (std::exception& e) {
64869       {
64870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64871       };
64872     } catch (...) {
64873       {
64874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64875       };
64876     }
64877   }
64878   jresult = result;
64879   return jresult;
64880 }
64881
64882
64883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64884   void * jresult ;
64885   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64886   float arg2 ;
64887   Dali::Vector3 arg3 ;
64888   Dali::Vector3 *argp3 ;
64889   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64890
64891   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64892   arg2 = (float)jarg2;
64893   argp3 = (Dali::Vector3 *)jarg3;
64894   if (!argp3) {
64895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64896     return 0;
64897   }
64898   arg3 = *argp3;
64899   {
64900     try {
64901       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64902     } catch (std::out_of_range& e) {
64903       {
64904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64905       };
64906     } catch (std::exception& e) {
64907       {
64908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64909       };
64910     } catch (...) {
64911       {
64912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64913       };
64914     }
64915   }
64916   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64917   return jresult;
64918 }
64919
64920
64921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64922   float jresult ;
64923   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64924   int arg2 ;
64925   float arg3 ;
64926   Dali::Vector3 *arg4 = 0 ;
64927   float result;
64928
64929   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64930   arg2 = (int)jarg2;
64931   arg3 = (float)jarg3;
64932   arg4 = (Dali::Vector3 *)jarg4;
64933   if (!arg4) {
64934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64935     return 0;
64936   }
64937   {
64938     try {
64939       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64940     } catch (std::out_of_range& e) {
64941       {
64942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (std::exception& e) {
64945       {
64946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (...) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64951       };
64952     }
64953   }
64954   jresult = result;
64955   return jresult;
64956 }
64957
64958
64959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64960   unsigned int jresult ;
64961   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64962   Dali::Vector3 arg2 ;
64963   Dali::Vector3 *argp2 ;
64964   unsigned int result;
64965
64966   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64967   argp2 = (Dali::Vector3 *)jarg2;
64968   if (!argp2) {
64969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64970     return 0;
64971   }
64972   arg2 = *argp2;
64973   {
64974     try {
64975       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64976     } catch (std::out_of_range& e) {
64977       {
64978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64979       };
64980     } catch (std::exception& e) {
64981       {
64982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64983       };
64984     } catch (...) {
64985       {
64986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64987       };
64988     }
64989   }
64990   jresult = result;
64991   return jresult;
64992 }
64993
64994
64995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64996   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64997   unsigned int arg2 ;
64998   Dali::Vector3 *arg3 = 0 ;
64999   Dali::Vector3 *arg4 = 0 ;
65000
65001   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65002   arg2 = (unsigned int)jarg2;
65003   arg3 = (Dali::Vector3 *)jarg3;
65004   if (!arg3) {
65005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65006     return ;
65007   }
65008   arg4 = (Dali::Vector3 *)jarg4;
65009   if (!arg4) {
65010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
65011     return ;
65012   }
65013   {
65014     try {
65015       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65023       };
65024     } catch (...) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65027       };
65028     }
65029   }
65030 }
65031
65032
65033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65034   void * jresult ;
65035   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65036   Dali::Degree result;
65037
65038   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65039   {
65040     try {
65041       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
65042     } catch (std::out_of_range& e) {
65043       {
65044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65045       };
65046     } catch (std::exception& e) {
65047       {
65048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65049       };
65050     } catch (...) {
65051       {
65052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65053       };
65054     }
65055   }
65056   jresult = new Dali::Degree((const Dali::Degree &)result);
65057   return jresult;
65058 }
65059
65060
65061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65062   float jresult ;
65063   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65064   float result;
65065
65066   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65067   {
65068     try {
65069       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65070     } catch (std::out_of_range& e) {
65071       {
65072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65073       };
65074     } catch (std::exception& e) {
65075       {
65076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65077       };
65078     } catch (...) {
65079       {
65080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65081       };
65082     }
65083   }
65084   jresult = result;
65085   return jresult;
65086 }
65087
65088
65089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65090   float jresult ;
65091   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65092   float result;
65093
65094   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65095   {
65096     try {
65097       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65098     } catch (std::out_of_range& e) {
65099       {
65100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65101       };
65102     } catch (std::exception& e) {
65103       {
65104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (...) {
65107       {
65108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65109       };
65110     }
65111   }
65112   jresult = result;
65113   return jresult;
65114 }
65115
65116
65117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65118   float jresult ;
65119   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65120   float result;
65121
65122   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65123   {
65124     try {
65125       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65126     } catch (std::out_of_range& e) {
65127       {
65128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (std::exception& e) {
65131       {
65132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65133       };
65134     } catch (...) {
65135       {
65136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65137       };
65138     }
65139   }
65140   jresult = result;
65141   return jresult;
65142 }
65143
65144
65145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65146   int jresult ;
65147   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65148   int arg2 ;
65149   int arg3 ;
65150   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65151   bool arg5 ;
65152   int result;
65153
65154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65155   arg2 = (int)jarg2;
65156   arg3 = (int)jarg3;
65157   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65158   arg5 = jarg5 ? true : false;
65159   {
65160     try {
65161       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65162     } catch (std::out_of_range& e) {
65163       {
65164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65165       };
65166     } catch (std::exception& e) {
65167       {
65168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65169       };
65170     } catch (...) {
65171       {
65172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65173       };
65174     }
65175   }
65176   jresult = result;
65177   return jresult;
65178 }
65179
65180
65181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65182   float jresult ;
65183   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65184   float result;
65185
65186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65187   {
65188     try {
65189       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65190     } catch (std::out_of_range& e) {
65191       {
65192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65193       };
65194     } catch (std::exception& e) {
65195       {
65196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65197       };
65198     } catch (...) {
65199       {
65200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65201       };
65202     }
65203   }
65204   jresult = result;
65205   return jresult;
65206 }
65207
65208
65209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65210   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65211   Dali::Actor *arg2 = 0 ;
65212   int arg3 ;
65213   Dali::Vector3 *arg4 = 0 ;
65214   Dali::Actor *arg5 = 0 ;
65215
65216   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65217   arg2 = (Dali::Actor *)jarg2;
65218   if (!arg2) {
65219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65220     return ;
65221   }
65222   arg3 = (int)jarg3;
65223   arg4 = (Dali::Vector3 *)jarg4;
65224   if (!arg4) {
65225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65226     return ;
65227   }
65228   arg5 = (Dali::Actor *)jarg5;
65229   if (!arg5) {
65230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65231     return ;
65232   }
65233   {
65234     try {
65235       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65236     } catch (std::out_of_range& e) {
65237       {
65238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65239       };
65240     } catch (std::exception& e) {
65241       {
65242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65243       };
65244     } catch (...) {
65245       {
65246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65247       };
65248     }
65249   }
65250 }
65251
65252
65253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65254   void * jresult ;
65255   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65256   int arg2 ;
65257   float arg3 ;
65258   Dali::Vector3 *arg4 = 0 ;
65259   Dali::Vector3 result;
65260
65261   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65262   arg2 = (int)jarg2;
65263   arg3 = (float)jarg3;
65264   arg4 = (Dali::Vector3 *)jarg4;
65265   if (!arg4) {
65266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65267     return 0;
65268   }
65269   {
65270     try {
65271       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65272     } catch (std::out_of_range& e) {
65273       {
65274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65275       };
65276     } catch (std::exception& e) {
65277       {
65278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65279       };
65280     } catch (...) {
65281       {
65282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65283       };
65284     }
65285   }
65286   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65287   return jresult;
65288 }
65289
65290
65291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65292   void * jresult ;
65293   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65294   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65295
65296   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65297   {
65298     try {
65299       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65300     } catch (std::out_of_range& e) {
65301       {
65302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65303       };
65304     } catch (std::exception& e) {
65305       {
65306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65307       };
65308     } catch (...) {
65309       {
65310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65311       };
65312     }
65313   }
65314   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65315   return jresult;
65316 }
65317
65318
65319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65320   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65321
65322   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65323   {
65324     try {
65325       delete arg1;
65326     } catch (std::out_of_range& e) {
65327       {
65328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65329       };
65330     } catch (std::exception& e) {
65331       {
65332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65333       };
65334     } catch (...) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65337       };
65338     }
65339   }
65340 }
65341
65342
65343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65344   unsigned int jresult ;
65345   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65346   unsigned int result;
65347
65348   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65349   {
65350     try {
65351       result = (unsigned int)(arg1)->GetNumberOfItems();
65352     } catch (std::out_of_range& e) {
65353       {
65354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65355       };
65356     } catch (std::exception& e) {
65357       {
65358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65359       };
65360     } catch (...) {
65361       {
65362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65363       };
65364     }
65365   }
65366   jresult = result;
65367   return jresult;
65368 }
65369
65370
65371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65372   void * jresult ;
65373   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65374   unsigned int arg2 ;
65375   Dali::Actor result;
65376
65377   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65378   arg2 = (unsigned int)jarg2;
65379   {
65380     try {
65381       result = (arg1)->NewItem(arg2);
65382     } catch (std::out_of_range& e) {
65383       {
65384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65385       };
65386     } catch (std::exception& e) {
65387       {
65388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65389       };
65390     } catch (...) {
65391       {
65392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65393       };
65394     }
65395   }
65396   jresult = new Dali::Actor((const Dali::Actor &)result);
65397   return jresult;
65398 }
65399
65400
65401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65402   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65403   unsigned int arg2 ;
65404   Dali::Actor arg3 ;
65405   Dali::Actor *argp3 ;
65406
65407   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65408   arg2 = (unsigned int)jarg2;
65409   argp3 = (Dali::Actor *)jarg3;
65410   if (!argp3) {
65411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65412     return ;
65413   }
65414   arg3 = *argp3;
65415   {
65416     try {
65417       (arg1)->ItemReleased(arg2,arg3);
65418     } catch (std::out_of_range& e) {
65419       {
65420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65421       };
65422     } catch (std::exception& e) {
65423       {
65424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65425       };
65426     } catch (...) {
65427       {
65428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65429       };
65430     }
65431   }
65432 }
65433
65434
65435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65436   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65437   unsigned int arg2 ;
65438   Dali::Actor arg3 ;
65439   Dali::Actor *argp3 ;
65440
65441   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65442   arg2 = (unsigned int)jarg2;
65443   argp3 = (Dali::Actor *)jarg3;
65444   if (!argp3) {
65445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65446     return ;
65447   }
65448   arg3 = *argp3;
65449   {
65450     try {
65451       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65452     } catch (std::out_of_range& e) {
65453       {
65454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65455       };
65456     } catch (std::exception& e) {
65457       {
65458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65459       };
65460     } catch (...) {
65461       {
65462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65463       };
65464     }
65465   }
65466 }
65467
65468
65469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65470   void * jresult ;
65471   Dali::Toolkit::ItemFactory *result = 0 ;
65472
65473   {
65474     try {
65475       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65476     } catch (std::out_of_range& e) {
65477       {
65478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65479       };
65480     } catch (std::exception& e) {
65481       {
65482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65483       };
65484     } catch (...) {
65485       {
65486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65487       };
65488     }
65489   }
65490   jresult = (void *)result;
65491   return jresult;
65492 }
65493
65494
65495 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) {
65496   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65497   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65498   if (director) {
65499     director->swig_connect_director(callback0, callback1, callback2);
65500   }
65501 }
65502
65503
65504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65505   int jresult ;
65506   int result;
65507
65508   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65509   jresult = (int)result;
65510   return jresult;
65511 }
65512
65513
65514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65515   int jresult ;
65516   int result;
65517
65518   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65519   jresult = (int)result;
65520   return jresult;
65521 }
65522
65523
65524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65525   int jresult ;
65526   int result;
65527
65528   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65529   jresult = (int)result;
65530   return jresult;
65531 }
65532
65533
65534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65535   int jresult ;
65536   int result;
65537
65538   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65539   jresult = (int)result;
65540   return jresult;
65541 }
65542
65543
65544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65545   int jresult ;
65546   int result;
65547
65548   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65549   jresult = (int)result;
65550   return jresult;
65551 }
65552
65553
65554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65555   int jresult ;
65556   int result;
65557
65558   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65559   jresult = (int)result;
65560   return jresult;
65561 }
65562
65563
65564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65565   int jresult ;
65566   int result;
65567
65568   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65569   jresult = (int)result;
65570   return jresult;
65571 }
65572
65573
65574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65575   int jresult ;
65576   int result;
65577
65578   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65579   jresult = (int)result;
65580   return jresult;
65581 }
65582
65583
65584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65585   int jresult ;
65586   int result;
65587
65588   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65589   jresult = (int)result;
65590   return jresult;
65591 }
65592
65593
65594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65595   int jresult ;
65596   int result;
65597
65598   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65599   jresult = (int)result;
65600   return jresult;
65601 }
65602
65603
65604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65605   int jresult ;
65606   int result;
65607
65608   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65609   jresult = (int)result;
65610   return jresult;
65611 }
65612
65613
65614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65615   void * jresult ;
65616   Dali::Toolkit::ItemView::Property *result = 0 ;
65617
65618   {
65619     try {
65620       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65621     } catch (std::out_of_range& e) {
65622       {
65623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65624       };
65625     } catch (std::exception& e) {
65626       {
65627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65628       };
65629     } catch (...) {
65630       {
65631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65632       };
65633     }
65634   }
65635   jresult = (void *)result;
65636   return jresult;
65637 }
65638
65639
65640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65641   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65642
65643   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65644   {
65645     try {
65646       delete arg1;
65647     } catch (std::out_of_range& e) {
65648       {
65649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65650       };
65651     } catch (std::exception& e) {
65652       {
65653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65654       };
65655     } catch (...) {
65656       {
65657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65658       };
65659     }
65660   }
65661 }
65662
65663
65664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65665   void * jresult ;
65666   Dali::Toolkit::ItemView *result = 0 ;
65667
65668   {
65669     try {
65670       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65671     } catch (std::out_of_range& e) {
65672       {
65673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65674       };
65675     } catch (std::exception& e) {
65676       {
65677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65678       };
65679     } catch (...) {
65680       {
65681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65682       };
65683     }
65684   }
65685   jresult = (void *)result;
65686   return jresult;
65687 }
65688
65689
65690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65691   void * jresult ;
65692   Dali::Toolkit::ItemView *arg1 = 0 ;
65693   Dali::Toolkit::ItemView *result = 0 ;
65694
65695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65696   if (!arg1) {
65697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65698     return 0;
65699   }
65700   {
65701     try {
65702       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (...) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65714       };
65715     }
65716   }
65717   jresult = (void *)result;
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65723   void * jresult ;
65724   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65725   Dali::Toolkit::ItemView *arg2 = 0 ;
65726   Dali::Toolkit::ItemView *result = 0 ;
65727
65728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65729   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65730   if (!arg2) {
65731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65732     return 0;
65733   }
65734   {
65735     try {
65736       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65737     } catch (std::out_of_range& e) {
65738       {
65739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65740       };
65741     } catch (std::exception& e) {
65742       {
65743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (...) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65748       };
65749     }
65750   }
65751   jresult = (void *)result;
65752   return jresult;
65753 }
65754
65755
65756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65758
65759   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65760   {
65761     try {
65762       delete arg1;
65763     } catch (std::out_of_range& e) {
65764       {
65765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65766       };
65767     } catch (std::exception& e) {
65768       {
65769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65770       };
65771     } catch (...) {
65772       {
65773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65774       };
65775     }
65776   }
65777 }
65778
65779
65780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65781   void * jresult ;
65782   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65783   Dali::Toolkit::ItemView result;
65784
65785   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65786   if (!arg1) {
65787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65788     return 0;
65789   }
65790   {
65791     try {
65792       result = Dali::Toolkit::ItemView::New(*arg1);
65793     } catch (std::out_of_range& e) {
65794       {
65795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65796       };
65797     } catch (std::exception& e) {
65798       {
65799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65800       };
65801     } catch (...) {
65802       {
65803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65804       };
65805     }
65806   }
65807   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65813   void * jresult ;
65814   Dali::BaseHandle arg1 ;
65815   Dali::BaseHandle *argp1 ;
65816   Dali::Toolkit::ItemView result;
65817
65818   argp1 = (Dali::BaseHandle *)jarg1;
65819   if (!argp1) {
65820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65821     return 0;
65822   }
65823   arg1 = *argp1;
65824   {
65825     try {
65826       result = Dali::Toolkit::ItemView::DownCast(arg1);
65827     } catch (std::out_of_range& e) {
65828       {
65829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65830       };
65831     } catch (std::exception& e) {
65832       {
65833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65834       };
65835     } catch (...) {
65836       {
65837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65838       };
65839     }
65840   }
65841   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65842   return jresult;
65843 }
65844
65845
65846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65847   unsigned int jresult ;
65848   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65849   unsigned int result;
65850
65851   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65852   {
65853     try {
65854       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65855     } catch (std::out_of_range& e) {
65856       {
65857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (std::exception& e) {
65860       {
65861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (...) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65866       };
65867     }
65868   }
65869   jresult = result;
65870   return jresult;
65871 }
65872
65873
65874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65875   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65876   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65877
65878   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65879   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65880   if (!arg2) {
65881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65882     return ;
65883   }
65884   {
65885     try {
65886       (arg1)->AddLayout(*arg2);
65887     } catch (std::out_of_range& e) {
65888       {
65889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65890       };
65891     } catch (std::exception& e) {
65892       {
65893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65894       };
65895     } catch (...) {
65896       {
65897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65898       };
65899     }
65900   }
65901 }
65902
65903
65904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65905   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65906   unsigned int arg2 ;
65907
65908   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65909   arg2 = (unsigned int)jarg2;
65910   {
65911     try {
65912       (arg1)->RemoveLayout(arg2);
65913     } catch (std::out_of_range& e) {
65914       {
65915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65916       };
65917     } catch (std::exception& e) {
65918       {
65919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65920       };
65921     } catch (...) {
65922       {
65923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65924       };
65925     }
65926   }
65927 }
65928
65929
65930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65931   void * jresult ;
65932   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65933   unsigned int arg2 ;
65934   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65935
65936   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65937   arg2 = (unsigned int)jarg2;
65938   {
65939     try {
65940       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65941     } catch (std::out_of_range& e) {
65942       {
65943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65944       };
65945     } catch (std::exception& e) {
65946       {
65947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65948       };
65949     } catch (...) {
65950       {
65951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65952       };
65953     }
65954   }
65955   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65956   return jresult;
65957 }
65958
65959
65960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65961   void * jresult ;
65962   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65963   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65964
65965   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65966   {
65967     try {
65968       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65969     } catch (std::out_of_range& e) {
65970       {
65971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65972       };
65973     } catch (std::exception& e) {
65974       {
65975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65976       };
65977     } catch (...) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65980       };
65981     }
65982   }
65983   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65984   return jresult;
65985 }
65986
65987
65988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65989   float jresult ;
65990   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65991   Dali::Toolkit::ItemId arg2 ;
65992   float result;
65993
65994   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65995   arg2 = (Dali::Toolkit::ItemId)jarg2;
65996   {
65997     try {
65998       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65999     } catch (std::out_of_range& e) {
66000       {
66001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66002       };
66003     } catch (std::exception& e) {
66004       {
66005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66006       };
66007     } catch (...) {
66008       {
66009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66010       };
66011     }
66012   }
66013   jresult = result;
66014   return jresult;
66015 }
66016
66017
66018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
66019   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66020   unsigned int arg2 ;
66021   Dali::Vector3 arg3 ;
66022   float arg4 ;
66023   Dali::Vector3 *argp3 ;
66024
66025   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66026   arg2 = (unsigned int)jarg2;
66027   argp3 = (Dali::Vector3 *)jarg3;
66028   if (!argp3) {
66029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66030     return ;
66031   }
66032   arg3 = *argp3;
66033   arg4 = (float)jarg4;
66034   {
66035     try {
66036       (arg1)->ActivateLayout(arg2,arg3,arg4);
66037     } catch (std::out_of_range& e) {
66038       {
66039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66040       };
66041     } catch (std::exception& e) {
66042       {
66043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66044       };
66045     } catch (...) {
66046       {
66047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66048       };
66049     }
66050   }
66051 }
66052
66053
66054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66056
66057   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66058   {
66059     try {
66060       (arg1)->DeactivateCurrentLayout();
66061     } catch (std::out_of_range& e) {
66062       {
66063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66064       };
66065     } catch (std::exception& e) {
66066       {
66067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66068       };
66069     } catch (...) {
66070       {
66071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66072       };
66073     }
66074   }
66075 }
66076
66077
66078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66079   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66080   float arg2 ;
66081
66082   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66083   arg2 = (float)jarg2;
66084   {
66085     try {
66086       (arg1)->SetMinimumSwipeSpeed(arg2);
66087     } catch (std::out_of_range& e) {
66088       {
66089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66090       };
66091     } catch (std::exception& e) {
66092       {
66093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66094       };
66095     } catch (...) {
66096       {
66097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66098       };
66099     }
66100   }
66101 }
66102
66103
66104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66105   float jresult ;
66106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66107   float result;
66108
66109   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66110   {
66111     try {
66112       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66113     } catch (std::out_of_range& e) {
66114       {
66115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66116       };
66117     } catch (std::exception& e) {
66118       {
66119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66120       };
66121     } catch (...) {
66122       {
66123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66124       };
66125     }
66126   }
66127   jresult = result;
66128   return jresult;
66129 }
66130
66131
66132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66133   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66134   float arg2 ;
66135
66136   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66137   arg2 = (float)jarg2;
66138   {
66139     try {
66140       (arg1)->SetMinimumSwipeDistance(arg2);
66141     } catch (std::out_of_range& e) {
66142       {
66143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66144       };
66145     } catch (std::exception& e) {
66146       {
66147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66148       };
66149     } catch (...) {
66150       {
66151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66152       };
66153     }
66154   }
66155 }
66156
66157
66158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66159   float jresult ;
66160   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66161   float result;
66162
66163   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66164   {
66165     try {
66166       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66167     } catch (std::out_of_range& e) {
66168       {
66169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66170       };
66171     } catch (std::exception& e) {
66172       {
66173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66174       };
66175     } catch (...) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66178       };
66179     }
66180   }
66181   jresult = result;
66182   return jresult;
66183 }
66184
66185
66186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66187   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66188   float arg2 ;
66189
66190   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66191   arg2 = (float)jarg2;
66192   {
66193     try {
66194       (arg1)->SetWheelScrollDistanceStep(arg2);
66195     } catch (std::out_of_range& e) {
66196       {
66197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (std::exception& e) {
66200       {
66201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66202       };
66203     } catch (...) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66206       };
66207     }
66208   }
66209 }
66210
66211
66212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66213   float jresult ;
66214   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66215   float result;
66216
66217   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66218   {
66219     try {
66220       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66221     } catch (std::out_of_range& e) {
66222       {
66223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66224       };
66225     } catch (std::exception& e) {
66226       {
66227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66228       };
66229     } catch (...) {
66230       {
66231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66232       };
66233     }
66234   }
66235   jresult = result;
66236   return jresult;
66237 }
66238
66239
66240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66241   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66242   bool arg2 ;
66243
66244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66245   arg2 = jarg2 ? true : false;
66246   {
66247     try {
66248       (arg1)->SetAnchoring(arg2);
66249     } catch (std::out_of_range& e) {
66250       {
66251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66252       };
66253     } catch (std::exception& e) {
66254       {
66255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66256       };
66257     } catch (...) {
66258       {
66259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66260       };
66261     }
66262   }
66263 }
66264
66265
66266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66267   unsigned int jresult ;
66268   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66269   bool result;
66270
66271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66272   {
66273     try {
66274       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66275     } catch (std::out_of_range& e) {
66276       {
66277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66278       };
66279     } catch (std::exception& e) {
66280       {
66281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66282       };
66283     } catch (...) {
66284       {
66285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66286       };
66287     }
66288   }
66289   jresult = result;
66290   return jresult;
66291 }
66292
66293
66294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66296   float arg2 ;
66297
66298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66299   arg2 = (float)jarg2;
66300   {
66301     try {
66302       (arg1)->SetAnchoringDuration(arg2);
66303     } catch (std::out_of_range& e) {
66304       {
66305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66306       };
66307     } catch (std::exception& e) {
66308       {
66309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66310       };
66311     } catch (...) {
66312       {
66313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66314       };
66315     }
66316   }
66317 }
66318
66319
66320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66321   float jresult ;
66322   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66323   float result;
66324
66325   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66326   {
66327     try {
66328       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66340       };
66341     }
66342   }
66343   jresult = result;
66344   return jresult;
66345 }
66346
66347
66348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66349   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66350   Dali::Toolkit::ItemId arg2 ;
66351   float arg3 ;
66352
66353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66354   arg2 = (Dali::Toolkit::ItemId)jarg2;
66355   arg3 = (float)jarg3;
66356   {
66357     try {
66358       (arg1)->ScrollToItem(arg2,arg3);
66359     } catch (std::out_of_range& e) {
66360       {
66361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66362       };
66363     } catch (std::exception& e) {
66364       {
66365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66366       };
66367     } catch (...) {
66368       {
66369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66370       };
66371     }
66372   }
66373 }
66374
66375
66376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66377   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66378   float arg2 ;
66379
66380   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66381   arg2 = (float)jarg2;
66382   {
66383     try {
66384       (arg1)->SetRefreshInterval(arg2);
66385     } catch (std::out_of_range& e) {
66386       {
66387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66388       };
66389     } catch (std::exception& e) {
66390       {
66391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66392       };
66393     } catch (...) {
66394       {
66395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66396       };
66397     }
66398   }
66399 }
66400
66401
66402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66403   float jresult ;
66404   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66405   float result;
66406
66407   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66408   {
66409     try {
66410       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66411     } catch (std::out_of_range& e) {
66412       {
66413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66414       };
66415     } catch (std::exception& e) {
66416       {
66417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66418       };
66419     } catch (...) {
66420       {
66421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66422       };
66423     }
66424   }
66425   jresult = result;
66426   return jresult;
66427 }
66428
66429
66430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66432
66433   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66434   {
66435     try {
66436       (arg1)->Refresh();
66437     } catch (std::out_of_range& e) {
66438       {
66439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66440       };
66441     } catch (std::exception& e) {
66442       {
66443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66444       };
66445     } catch (...) {
66446       {
66447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66448       };
66449     }
66450   }
66451 }
66452
66453
66454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66455   void * jresult ;
66456   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66457   Dali::Toolkit::ItemId arg2 ;
66458   Dali::Actor result;
66459
66460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66461   arg2 = (Dali::Toolkit::ItemId)jarg2;
66462   {
66463     try {
66464       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66465     } catch (std::out_of_range& e) {
66466       {
66467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66468       };
66469     } catch (std::exception& e) {
66470       {
66471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66472       };
66473     } catch (...) {
66474       {
66475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66476       };
66477     }
66478   }
66479   jresult = new Dali::Actor((const Dali::Actor &)result);
66480   return jresult;
66481 }
66482
66483
66484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66485   unsigned int jresult ;
66486   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66487   Dali::Actor arg2 ;
66488   Dali::Actor *argp2 ;
66489   Dali::Toolkit::ItemId result;
66490
66491   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66492   argp2 = (Dali::Actor *)jarg2;
66493   if (!argp2) {
66494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66495     return 0;
66496   }
66497   arg2 = *argp2;
66498   {
66499     try {
66500       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66501     } catch (std::out_of_range& e) {
66502       {
66503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66504       };
66505     } catch (std::exception& e) {
66506       {
66507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66508       };
66509     } catch (...) {
66510       {
66511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66512       };
66513     }
66514   }
66515   jresult = result;
66516   return jresult;
66517 }
66518
66519
66520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66521   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66522   Dali::Toolkit::Item arg2 ;
66523   float arg3 ;
66524   Dali::Toolkit::Item *argp2 ;
66525
66526   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66527   argp2 = (Dali::Toolkit::Item *)jarg2;
66528   if (!argp2) {
66529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66530     return ;
66531   }
66532   arg2 = *argp2;
66533   arg3 = (float)jarg3;
66534   {
66535     try {
66536       (arg1)->InsertItem(arg2,arg3);
66537     } catch (std::out_of_range& e) {
66538       {
66539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66540       };
66541     } catch (std::exception& e) {
66542       {
66543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66544       };
66545     } catch (...) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66548       };
66549     }
66550   }
66551 }
66552
66553
66554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66555   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66556   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66557   float arg3 ;
66558
66559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66560   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66561   if (!arg2) {
66562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66563     return ;
66564   }
66565   arg3 = (float)jarg3;
66566   {
66567     try {
66568       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66569     } catch (std::out_of_range& e) {
66570       {
66571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66572       };
66573     } catch (std::exception& e) {
66574       {
66575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66576       };
66577     } catch (...) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66580       };
66581     }
66582   }
66583 }
66584
66585
66586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66588   Dali::Toolkit::ItemId arg2 ;
66589   float arg3 ;
66590
66591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66592   arg2 = (Dali::Toolkit::ItemId)jarg2;
66593   arg3 = (float)jarg3;
66594   {
66595     try {
66596       (arg1)->RemoveItem(arg2,arg3);
66597     } catch (std::out_of_range& e) {
66598       {
66599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66600       };
66601     } catch (std::exception& e) {
66602       {
66603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66604       };
66605     } catch (...) {
66606       {
66607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66608       };
66609     }
66610   }
66611 }
66612
66613
66614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66615   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66616   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66617   float arg3 ;
66618
66619   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66620   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66621   if (!arg2) {
66622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66623     return ;
66624   }
66625   arg3 = (float)jarg3;
66626   {
66627     try {
66628       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66629     } catch (std::out_of_range& e) {
66630       {
66631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66632       };
66633     } catch (std::exception& e) {
66634       {
66635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66636       };
66637     } catch (...) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66640       };
66641     }
66642   }
66643 }
66644
66645
66646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66647   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66648   Dali::Toolkit::Item arg2 ;
66649   float arg3 ;
66650   Dali::Toolkit::Item *argp2 ;
66651
66652   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66653   argp2 = (Dali::Toolkit::Item *)jarg2;
66654   if (!argp2) {
66655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66656     return ;
66657   }
66658   arg2 = *argp2;
66659   arg3 = (float)jarg3;
66660   {
66661     try {
66662       (arg1)->ReplaceItem(arg2,arg3);
66663     } catch (std::out_of_range& e) {
66664       {
66665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66666       };
66667     } catch (std::exception& e) {
66668       {
66669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66670       };
66671     } catch (...) {
66672       {
66673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66674       };
66675     }
66676   }
66677 }
66678
66679
66680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66681   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66682   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66683   float arg3 ;
66684
66685   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66686   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66687   if (!arg2) {
66688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66689     return ;
66690   }
66691   arg3 = (float)jarg3;
66692   {
66693     try {
66694       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66695     } catch (std::out_of_range& e) {
66696       {
66697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66698       };
66699     } catch (std::exception& e) {
66700       {
66701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66702       };
66703     } catch (...) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66706       };
66707     }
66708   }
66709 }
66710
66711
66712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66713   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66714   Dali::Vector3 *arg2 = 0 ;
66715
66716   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66717   arg2 = (Dali::Vector3 *)jarg2;
66718   if (!arg2) {
66719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66720     return ;
66721   }
66722   {
66723     try {
66724       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66736       };
66737     }
66738   }
66739 }
66740
66741
66742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66743   void * jresult ;
66744   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66745   Dali::Vector3 result;
66746
66747   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66748   {
66749     try {
66750       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66751     } catch (std::out_of_range& e) {
66752       {
66753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66754       };
66755     } catch (std::exception& e) {
66756       {
66757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66758       };
66759     } catch (...) {
66760       {
66761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66762       };
66763     }
66764   }
66765   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66766   return jresult;
66767 }
66768
66769
66770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66771   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66772   Dali::Vector3 *arg2 = 0 ;
66773
66774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66775   arg2 = (Dali::Vector3 *)jarg2;
66776   if (!arg2) {
66777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66778     return ;
66779   }
66780   {
66781     try {
66782       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66783     } catch (std::out_of_range& e) {
66784       {
66785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66786       };
66787     } catch (std::exception& e) {
66788       {
66789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66790       };
66791     } catch (...) {
66792       {
66793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66794       };
66795     }
66796   }
66797 }
66798
66799
66800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66801   void * jresult ;
66802   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66803   Dali::Vector3 result;
66804
66805   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66806   {
66807     try {
66808       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66809     } catch (std::out_of_range& e) {
66810       {
66811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66812       };
66813     } catch (std::exception& e) {
66814       {
66815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66816       };
66817     } catch (...) {
66818       {
66819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66820       };
66821     }
66822   }
66823   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66824   return jresult;
66825 }
66826
66827
66828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66829   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66830   Dali::Toolkit::ItemRange *arg2 = 0 ;
66831
66832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66833   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66834   if (!arg2) {
66835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66836     return ;
66837   }
66838   {
66839     try {
66840       (arg1)->GetItemsRange(*arg2);
66841     } catch (std::out_of_range& e) {
66842       {
66843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66844       };
66845     } catch (std::exception& e) {
66846       {
66847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66848       };
66849     } catch (...) {
66850       {
66851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66852       };
66853     }
66854   }
66855 }
66856
66857
66858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66859   void * jresult ;
66860   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66861   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66862
66863   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66864   {
66865     try {
66866       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66867     } catch (std::out_of_range& e) {
66868       {
66869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66870       };
66871     } catch (std::exception& e) {
66872       {
66873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66874       };
66875     } catch (...) {
66876       {
66877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66878       };
66879     }
66880   }
66881   jresult = (void *)result;
66882   return jresult;
66883 }
66884
66885
66886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66887   Dali::Vector3 *arg1 = 0 ;
66888   PropertyInputContainer *arg2 = 0 ;
66889
66890   arg1 = (Dali::Vector3 *)jarg1;
66891   if (!arg1) {
66892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66893     return ;
66894   }
66895   arg2 = (PropertyInputContainer *)jarg2;
66896   if (!arg2) {
66897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66898     return ;
66899   }
66900   {
66901     try {
66902       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66903     } catch (std::out_of_range& e) {
66904       {
66905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66906       };
66907     } catch (std::exception& e) {
66908       {
66909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66910       };
66911     } catch (...) {
66912       {
66913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66914       };
66915     }
66916   }
66917 }
66918
66919
66920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66921   Dali::Vector3 *arg1 = 0 ;
66922   PropertyInputContainer *arg2 = 0 ;
66923
66924   arg1 = (Dali::Vector3 *)jarg1;
66925   if (!arg1) {
66926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66927     return ;
66928   }
66929   arg2 = (PropertyInputContainer *)jarg2;
66930   if (!arg2) {
66931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66932     return ;
66933   }
66934   {
66935     try {
66936       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66937     } catch (std::out_of_range& e) {
66938       {
66939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66940       };
66941     } catch (std::exception& e) {
66942       {
66943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66944       };
66945     } catch (...) {
66946       {
66947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66948       };
66949     }
66950   }
66951 }
66952
66953
66954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66955   void * jresult ;
66956   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66957
66958   {
66959     try {
66960       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66961     } catch (std::out_of_range& e) {
66962       {
66963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66964       };
66965     } catch (std::exception& e) {
66966       {
66967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66968       };
66969     } catch (...) {
66970       {
66971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66972       };
66973     }
66974   }
66975   jresult = (void *)result;
66976   return jresult;
66977 }
66978
66979
66980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66981   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66982
66983   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66984   {
66985     try {
66986       delete arg1;
66987     } catch (std::out_of_range& e) {
66988       {
66989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66990       };
66991     } catch (std::exception& e) {
66992       {
66993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66994       };
66995     } catch (...) {
66996       {
66997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66998       };
66999     }
67000   }
67001 }
67002
67003
67004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
67005   void * jresult ;
67006   Dali::Path arg1 ;
67007   Dali::Vector3 *arg2 = 0 ;
67008   Dali::Property::Index arg3 ;
67009   Dali::Vector3 *arg4 = 0 ;
67010   unsigned int arg5 ;
67011   Dali::Path *argp1 ;
67012   Dali::Toolkit::ScrollViewPagePathEffect result;
67013
67014   argp1 = (Dali::Path *)jarg1;
67015   if (!argp1) {
67016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
67017     return 0;
67018   }
67019   arg1 = *argp1;
67020   arg2 = (Dali::Vector3 *)jarg2;
67021   if (!arg2) {
67022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67023     return 0;
67024   }
67025   arg3 = (Dali::Property::Index)jarg3;
67026   arg4 = (Dali::Vector3 *)jarg4;
67027   if (!arg4) {
67028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67029     return 0;
67030   }
67031   arg5 = (unsigned int)jarg5;
67032   {
67033     try {
67034       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
67035     } catch (std::out_of_range& e) {
67036       {
67037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67038       };
67039     } catch (std::exception& e) {
67040       {
67041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67042       };
67043     } catch (...) {
67044       {
67045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67046       };
67047     }
67048   }
67049   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67050   return jresult;
67051 }
67052
67053
67054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67055   void * jresult ;
67056   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67057
67058   {
67059     try {
67060       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67061     } catch (std::out_of_range& e) {
67062       {
67063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67064       };
67065     } catch (std::exception& e) {
67066       {
67067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67068       };
67069     } catch (...) {
67070       {
67071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67072       };
67073     }
67074   }
67075   jresult = (void *)result;
67076   return jresult;
67077 }
67078
67079
67080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67081   void * jresult ;
67082   Dali::BaseHandle arg1 ;
67083   Dali::BaseHandle *argp1 ;
67084   Dali::Toolkit::ScrollViewPagePathEffect result;
67085
67086   argp1 = (Dali::BaseHandle *)jarg1;
67087   if (!argp1) {
67088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67089     return 0;
67090   }
67091   arg1 = *argp1;
67092   {
67093     try {
67094       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67095     } catch (std::out_of_range& e) {
67096       {
67097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67098       };
67099     } catch (std::exception& e) {
67100       {
67101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67102       };
67103     } catch (...) {
67104       {
67105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67106       };
67107     }
67108   }
67109   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67110   return jresult;
67111 }
67112
67113
67114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67115   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67116   Dali::Actor arg2 ;
67117   unsigned int arg3 ;
67118   Dali::Actor *argp2 ;
67119
67120   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67121   argp2 = (Dali::Actor *)jarg2;
67122   if (!argp2) {
67123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67124     return ;
67125   }
67126   arg2 = *argp2;
67127   arg3 = (unsigned int)jarg3;
67128   {
67129     try {
67130       (arg1)->ApplyToPage(arg2,arg3);
67131     } catch (std::out_of_range& e) {
67132       {
67133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67134       };
67135     } catch (std::exception& e) {
67136       {
67137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67138       };
67139     } catch (...) {
67140       {
67141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67142       };
67143     }
67144   }
67145 }
67146
67147
67148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67149   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67150
67151   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67152   {
67153     try {
67154       delete arg1;
67155     } catch (std::out_of_range& e) {
67156       {
67157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67158       };
67159     } catch (std::exception& e) {
67160       {
67161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67162       };
67163     } catch (...) {
67164       {
67165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67166       };
67167     }
67168   }
67169 }
67170
67171
67172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67173   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67174   Dali::Toolkit::ClampState arg2 ;
67175
67176   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67177   arg2 = (Dali::Toolkit::ClampState)jarg2;
67178   if (arg1) (arg1)->x = arg2;
67179 }
67180
67181
67182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67183   int jresult ;
67184   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67185   Dali::Toolkit::ClampState result;
67186
67187   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67188   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67189   jresult = (int)result;
67190   return jresult;
67191 }
67192
67193
67194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67195   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67196   Dali::Toolkit::ClampState arg2 ;
67197
67198   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67199   arg2 = (Dali::Toolkit::ClampState)jarg2;
67200   if (arg1) (arg1)->y = arg2;
67201 }
67202
67203
67204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67205   int jresult ;
67206   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67207   Dali::Toolkit::ClampState result;
67208
67209   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67210   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67211   jresult = (int)result;
67212   return jresult;
67213 }
67214
67215
67216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67217   void * jresult ;
67218   Dali::Toolkit::ClampState2D *result = 0 ;
67219
67220   {
67221     try {
67222       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67223     } catch (std::out_of_range& e) {
67224       {
67225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67226       };
67227     } catch (std::exception& e) {
67228       {
67229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67230       };
67231     } catch (...) {
67232       {
67233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67234       };
67235     }
67236   }
67237   jresult = (void *)result;
67238   return jresult;
67239 }
67240
67241
67242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67243   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67244
67245   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67246   {
67247     try {
67248       delete arg1;
67249     } catch (std::out_of_range& e) {
67250       {
67251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67252       };
67253     } catch (std::exception& e) {
67254       {
67255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67256       };
67257     } catch (...) {
67258       {
67259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67260       };
67261     }
67262   }
67263 }
67264
67265
67266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67267   void * jresult ;
67268   float arg1 ;
67269   float arg2 ;
67270   bool arg3 ;
67271   Dali::Toolkit::RulerDomain *result = 0 ;
67272
67273   arg1 = (float)jarg1;
67274   arg2 = (float)jarg2;
67275   arg3 = jarg3 ? true : false;
67276   {
67277     try {
67278       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67279     } catch (std::out_of_range& e) {
67280       {
67281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67282       };
67283     } catch (std::exception& e) {
67284       {
67285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (...) {
67288       {
67289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67290       };
67291     }
67292   }
67293   jresult = (void *)result;
67294   return jresult;
67295 }
67296
67297
67298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67299   void * jresult ;
67300   float arg1 ;
67301   float arg2 ;
67302   Dali::Toolkit::RulerDomain *result = 0 ;
67303
67304   arg1 = (float)jarg1;
67305   arg2 = (float)jarg2;
67306   {
67307     try {
67308       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67309     } catch (std::out_of_range& e) {
67310       {
67311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67312       };
67313     } catch (std::exception& e) {
67314       {
67315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67316       };
67317     } catch (...) {
67318       {
67319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67320       };
67321     }
67322   }
67323   jresult = (void *)result;
67324   return jresult;
67325 }
67326
67327
67328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67329   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67330   float arg2 ;
67331
67332   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67333   arg2 = (float)jarg2;
67334   if (arg1) (arg1)->min = arg2;
67335 }
67336
67337
67338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67339   float jresult ;
67340   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67341   float result;
67342
67343   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67344   result = (float) ((arg1)->min);
67345   jresult = result;
67346   return jresult;
67347 }
67348
67349
67350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67351   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67352   float arg2 ;
67353
67354   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67355   arg2 = (float)jarg2;
67356   if (arg1) (arg1)->max = arg2;
67357 }
67358
67359
67360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67361   float jresult ;
67362   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67363   float result;
67364
67365   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67366   result = (float) ((arg1)->max);
67367   jresult = result;
67368   return jresult;
67369 }
67370
67371
67372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67373   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67374   bool arg2 ;
67375
67376   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67377   arg2 = jarg2 ? true : false;
67378   if (arg1) (arg1)->enabled = arg2;
67379 }
67380
67381
67382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67383   unsigned int jresult ;
67384   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67385   bool result;
67386
67387   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67388   result = (bool) ((arg1)->enabled);
67389   jresult = result;
67390   return jresult;
67391 }
67392
67393
67394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67395   float jresult ;
67396   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67397   float arg2 ;
67398   float arg3 ;
67399   float arg4 ;
67400   float result;
67401
67402   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67403   arg2 = (float)jarg2;
67404   arg3 = (float)jarg3;
67405   arg4 = (float)jarg4;
67406   {
67407     try {
67408       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67409     } catch (std::out_of_range& e) {
67410       {
67411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67412       };
67413     } catch (std::exception& e) {
67414       {
67415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67416       };
67417     } catch (...) {
67418       {
67419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67420       };
67421     }
67422   }
67423   jresult = result;
67424   return jresult;
67425 }
67426
67427
67428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67429   float jresult ;
67430   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67431   float arg2 ;
67432   float arg3 ;
67433   float result;
67434
67435   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67436   arg2 = (float)jarg2;
67437   arg3 = (float)jarg3;
67438   {
67439     try {
67440       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67441     } catch (std::out_of_range& e) {
67442       {
67443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67444       };
67445     } catch (std::exception& e) {
67446       {
67447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67448       };
67449     } catch (...) {
67450       {
67451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67452       };
67453     }
67454   }
67455   jresult = result;
67456   return jresult;
67457 }
67458
67459
67460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67461   float jresult ;
67462   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67463   float arg2 ;
67464   float result;
67465
67466   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67467   arg2 = (float)jarg2;
67468   {
67469     try {
67470       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67471     } catch (std::out_of_range& e) {
67472       {
67473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (std::exception& e) {
67476       {
67477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67478       };
67479     } catch (...) {
67480       {
67481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67482       };
67483     }
67484   }
67485   jresult = result;
67486   return jresult;
67487 }
67488
67489
67490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67491   float jresult ;
67492   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67493   float arg2 ;
67494   float arg3 ;
67495   float arg4 ;
67496   Dali::Toolkit::ClampState *arg5 = 0 ;
67497   float result;
67498
67499   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67500   arg2 = (float)jarg2;
67501   arg3 = (float)jarg3;
67502   arg4 = (float)jarg4;
67503   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67504   if (!arg5) {
67505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67506     return 0;
67507   }
67508   {
67509     try {
67510       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67511     } catch (std::out_of_range& e) {
67512       {
67513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67514       };
67515     } catch (std::exception& e) {
67516       {
67517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67518       };
67519     } catch (...) {
67520       {
67521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67522       };
67523     }
67524   }
67525   jresult = result;
67526   return jresult;
67527 }
67528
67529
67530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67531   float jresult ;
67532   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67533   float result;
67534
67535   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67536   {
67537     try {
67538       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67539     } catch (std::out_of_range& e) {
67540       {
67541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67542       };
67543     } catch (std::exception& e) {
67544       {
67545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67546       };
67547     } catch (...) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67550       };
67551     }
67552   }
67553   jresult = result;
67554   return jresult;
67555 }
67556
67557
67558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67559   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67560
67561   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67562   {
67563     try {
67564       delete arg1;
67565     } catch (std::out_of_range& e) {
67566       {
67567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67568       };
67569     } catch (std::exception& e) {
67570       {
67571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67572       };
67573     } catch (...) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67576       };
67577     }
67578   }
67579 }
67580
67581
67582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67583   float jresult ;
67584   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67585   float arg2 ;
67586   float arg3 ;
67587   float result;
67588
67589   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67590   arg2 = (float)jarg2;
67591   arg3 = (float)jarg3;
67592   {
67593     try {
67594       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67595     } catch (std::out_of_range& e) {
67596       {
67597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67598       };
67599     } catch (std::exception& e) {
67600       {
67601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67602       };
67603     } catch (...) {
67604       {
67605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67606       };
67607     }
67608   }
67609   jresult = result;
67610   return jresult;
67611 }
67612
67613
67614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67615   float jresult ;
67616   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67617   float arg2 ;
67618   float result;
67619
67620   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67621   arg2 = (float)jarg2;
67622   {
67623     try {
67624       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67625     } catch (std::out_of_range& e) {
67626       {
67627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67628       };
67629     } catch (std::exception& e) {
67630       {
67631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67632       };
67633     } catch (...) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67636       };
67637     }
67638   }
67639   jresult = result;
67640   return jresult;
67641 }
67642
67643
67644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67645   float jresult ;
67646   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67647   unsigned int arg2 ;
67648   unsigned int *arg3 = 0 ;
67649   bool arg4 ;
67650   float result;
67651
67652   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67653   arg2 = (unsigned int)jarg2;
67654   arg3 = (unsigned int *)jarg3;
67655   arg4 = jarg4 ? true : false;
67656   {
67657     try {
67658       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67659     } catch (std::out_of_range& e) {
67660       {
67661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (std::exception& e) {
67664       {
67665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (...) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67670       };
67671     }
67672   }
67673   jresult = result;
67674   return jresult;
67675 }
67676
67677
67678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67679   unsigned int jresult ;
67680   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67681   float arg2 ;
67682   bool arg3 ;
67683   unsigned int result;
67684
67685   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67686   arg2 = (float)jarg2;
67687   arg3 = jarg3 ? true : false;
67688   {
67689     try {
67690       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67691     } catch (std::out_of_range& e) {
67692       {
67693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67694       };
67695     } catch (std::exception& e) {
67696       {
67697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67698       };
67699     } catch (...) {
67700       {
67701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67702       };
67703     }
67704   }
67705   jresult = result;
67706   return jresult;
67707 }
67708
67709
67710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67711   unsigned int jresult ;
67712   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67713   unsigned int result;
67714
67715   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67716   {
67717     try {
67718       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67719     } catch (std::out_of_range& e) {
67720       {
67721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67722       };
67723     } catch (std::exception& e) {
67724       {
67725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67726       };
67727     } catch (...) {
67728       {
67729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67730       };
67731     }
67732   }
67733   jresult = result;
67734   return jresult;
67735 }
67736
67737
67738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67739   int jresult ;
67740   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67741   Dali::Toolkit::Ruler::RulerType result;
67742
67743   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67744   {
67745     try {
67746       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67747     } catch (std::out_of_range& e) {
67748       {
67749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67750       };
67751     } catch (std::exception& e) {
67752       {
67753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (...) {
67756       {
67757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67758       };
67759     }
67760   }
67761   jresult = (int)result;
67762   return jresult;
67763 }
67764
67765
67766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67767   unsigned int jresult ;
67768   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67769   bool result;
67770
67771   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67772   {
67773     try {
67774       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67775     } catch (std::out_of_range& e) {
67776       {
67777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67778       };
67779     } catch (std::exception& e) {
67780       {
67781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67782       };
67783     } catch (...) {
67784       {
67785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67786       };
67787     }
67788   }
67789   jresult = result;
67790   return jresult;
67791 }
67792
67793
67794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67795   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67796
67797   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67798   {
67799     try {
67800       (arg1)->Enable();
67801     } catch (std::out_of_range& e) {
67802       {
67803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67804       };
67805     } catch (std::exception& e) {
67806       {
67807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67808       };
67809     } catch (...) {
67810       {
67811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67812       };
67813     }
67814   }
67815 }
67816
67817
67818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67819   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67820
67821   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67822   {
67823     try {
67824       (arg1)->Disable();
67825     } catch (std::out_of_range& e) {
67826       {
67827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67828       };
67829     } catch (std::exception& e) {
67830       {
67831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67832       };
67833     } catch (...) {
67834       {
67835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67836       };
67837     }
67838   }
67839 }
67840
67841
67842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67843   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67844   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67845   Dali::Toolkit::RulerDomain *argp2 ;
67846
67847   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67848   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67849   if (!argp2) {
67850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67851     return ;
67852   }
67853   arg2 = *argp2;
67854   {
67855     try {
67856       (arg1)->SetDomain(arg2);
67857     } catch (std::out_of_range& e) {
67858       {
67859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67860       };
67861     } catch (std::exception& e) {
67862       {
67863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67864       };
67865     } catch (...) {
67866       {
67867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67868       };
67869     }
67870   }
67871 }
67872
67873
67874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67875   void * jresult ;
67876   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67877   Dali::Toolkit::RulerDomain *result = 0 ;
67878
67879   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67880   {
67881     try {
67882       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67883     } catch (std::out_of_range& e) {
67884       {
67885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67886       };
67887     } catch (std::exception& e) {
67888       {
67889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67890       };
67891     } catch (...) {
67892       {
67893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67894       };
67895     }
67896   }
67897   jresult = (void *)result;
67898   return jresult;
67899 }
67900
67901
67902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67903   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67904
67905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67906   {
67907     try {
67908       (arg1)->DisableDomain();
67909     } catch (std::out_of_range& e) {
67910       {
67911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67912       };
67913     } catch (std::exception& e) {
67914       {
67915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67916       };
67917     } catch (...) {
67918       {
67919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67920       };
67921     }
67922   }
67923 }
67924
67925
67926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67927   float jresult ;
67928   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67929   float arg2 ;
67930   float arg3 ;
67931   float arg4 ;
67932   float result;
67933
67934   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67935   arg2 = (float)jarg2;
67936   arg3 = (float)jarg3;
67937   arg4 = (float)jarg4;
67938   {
67939     try {
67940       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67941     } catch (std::out_of_range& e) {
67942       {
67943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67944       };
67945     } catch (std::exception& e) {
67946       {
67947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67948       };
67949     } catch (...) {
67950       {
67951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67952       };
67953     }
67954   }
67955   jresult = result;
67956   return jresult;
67957 }
67958
67959
67960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67961   float jresult ;
67962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67963   float arg2 ;
67964   float arg3 ;
67965   float result;
67966
67967   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67968   arg2 = (float)jarg2;
67969   arg3 = (float)jarg3;
67970   {
67971     try {
67972       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67973     } catch (std::out_of_range& e) {
67974       {
67975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67976       };
67977     } catch (std::exception& e) {
67978       {
67979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67980       };
67981     } catch (...) {
67982       {
67983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67984       };
67985     }
67986   }
67987   jresult = result;
67988   return jresult;
67989 }
67990
67991
67992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67993   float jresult ;
67994   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67995   float arg2 ;
67996   float result;
67997
67998   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67999   arg2 = (float)jarg2;
68000   {
68001     try {
68002       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
68003     } catch (std::out_of_range& e) {
68004       {
68005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68006       };
68007     } catch (std::exception& e) {
68008       {
68009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68010       };
68011     } catch (...) {
68012       {
68013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68014       };
68015     }
68016   }
68017   jresult = result;
68018   return jresult;
68019 }
68020
68021
68022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68023   float jresult ;
68024   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68025   float arg2 ;
68026   float arg3 ;
68027   float arg4 ;
68028   Dali::Toolkit::ClampState *arg5 = 0 ;
68029   float result;
68030
68031   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68032   arg2 = (float)jarg2;
68033   arg3 = (float)jarg3;
68034   arg4 = (float)jarg4;
68035   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68036   if (!arg5) {
68037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68038     return 0;
68039   }
68040   {
68041     try {
68042       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68043     } catch (std::out_of_range& e) {
68044       {
68045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68046       };
68047     } catch (std::exception& e) {
68048       {
68049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68050       };
68051     } catch (...) {
68052       {
68053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68054       };
68055     }
68056   }
68057   jresult = result;
68058   return jresult;
68059 }
68060
68061
68062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68063   float jresult ;
68064   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68065   float arg2 ;
68066   float arg3 ;
68067   float arg4 ;
68068   float arg5 ;
68069   float result;
68070
68071   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68072   arg2 = (float)jarg2;
68073   arg3 = (float)jarg3;
68074   arg4 = (float)jarg4;
68075   arg5 = (float)jarg5;
68076   {
68077     try {
68078       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68079     } catch (std::out_of_range& e) {
68080       {
68081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68082       };
68083     } catch (std::exception& e) {
68084       {
68085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68086       };
68087     } catch (...) {
68088       {
68089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68090       };
68091     }
68092   }
68093   jresult = result;
68094   return jresult;
68095 }
68096
68097
68098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68099   float jresult ;
68100   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68101   float arg2 ;
68102   float arg3 ;
68103   float arg4 ;
68104   float result;
68105
68106   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68107   arg2 = (float)jarg2;
68108   arg3 = (float)jarg3;
68109   arg4 = (float)jarg4;
68110   {
68111     try {
68112       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68113     } catch (std::out_of_range& e) {
68114       {
68115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68116       };
68117     } catch (std::exception& e) {
68118       {
68119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68120       };
68121     } catch (...) {
68122       {
68123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68124       };
68125     }
68126   }
68127   jresult = result;
68128   return jresult;
68129 }
68130
68131
68132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68133   float jresult ;
68134   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68135   float arg2 ;
68136   float arg3 ;
68137   float result;
68138
68139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68140   arg2 = (float)jarg2;
68141   arg3 = (float)jarg3;
68142   {
68143     try {
68144       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68145     } catch (std::out_of_range& e) {
68146       {
68147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68148       };
68149     } catch (std::exception& e) {
68150       {
68151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68152       };
68153     } catch (...) {
68154       {
68155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68156       };
68157     }
68158   }
68159   jresult = result;
68160   return jresult;
68161 }
68162
68163
68164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68165   float jresult ;
68166   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68167   float arg2 ;
68168   float result;
68169
68170   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68171   arg2 = (float)jarg2;
68172   {
68173     try {
68174       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68175     } catch (std::out_of_range& e) {
68176       {
68177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68178       };
68179     } catch (std::exception& e) {
68180       {
68181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68186       };
68187     }
68188   }
68189   jresult = result;
68190   return jresult;
68191 }
68192
68193
68194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68195   float jresult ;
68196   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68197   float arg2 ;
68198   float arg3 ;
68199   float arg4 ;
68200   float arg5 ;
68201   Dali::Toolkit::ClampState *arg6 = 0 ;
68202   float result;
68203
68204   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68205   arg2 = (float)jarg2;
68206   arg3 = (float)jarg3;
68207   arg4 = (float)jarg4;
68208   arg5 = (float)jarg5;
68209   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68210   if (!arg6) {
68211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68212     return 0;
68213   }
68214   {
68215     try {
68216       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68217     } catch (std::out_of_range& e) {
68218       {
68219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68220       };
68221     } catch (std::exception& e) {
68222       {
68223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68224       };
68225     } catch (...) {
68226       {
68227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68228       };
68229     }
68230   }
68231   jresult = result;
68232   return jresult;
68233 }
68234
68235
68236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68237   void * jresult ;
68238   Dali::Toolkit::DefaultRuler *result = 0 ;
68239
68240   {
68241     try {
68242       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68243     } catch (std::out_of_range& e) {
68244       {
68245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68246       };
68247     } catch (std::exception& e) {
68248       {
68249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68250       };
68251     } catch (...) {
68252       {
68253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68254       };
68255     }
68256   }
68257   jresult = (void *)result;
68258   return jresult;
68259 }
68260
68261
68262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68263   float jresult ;
68264   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68265   float arg2 ;
68266   float arg3 ;
68267   float result;
68268
68269   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68270   arg2 = (float)jarg2;
68271   arg3 = (float)jarg3;
68272   {
68273     try {
68274       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68275     } catch (std::out_of_range& e) {
68276       {
68277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68278       };
68279     } catch (std::exception& e) {
68280       {
68281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68282       };
68283     } catch (...) {
68284       {
68285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68286       };
68287     }
68288   }
68289   jresult = result;
68290   return jresult;
68291 }
68292
68293
68294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68295   float jresult ;
68296   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68297   unsigned int arg2 ;
68298   unsigned int *arg3 = 0 ;
68299   bool arg4 ;
68300   float result;
68301
68302   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68303   arg2 = (unsigned int)jarg2;
68304   arg3 = (unsigned int *)jarg3;
68305   arg4 = jarg4 ? true : false;
68306   {
68307     try {
68308       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68309     } catch (std::out_of_range& e) {
68310       {
68311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68312       };
68313     } catch (std::exception& e) {
68314       {
68315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68316       };
68317     } catch (...) {
68318       {
68319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68320       };
68321     }
68322   }
68323   jresult = result;
68324   return jresult;
68325 }
68326
68327
68328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68329   unsigned int jresult ;
68330   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68331   float arg2 ;
68332   bool arg3 ;
68333   unsigned int result;
68334
68335   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68336   arg2 = (float)jarg2;
68337   arg3 = jarg3 ? true : false;
68338   {
68339     try {
68340       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68341     } catch (std::out_of_range& e) {
68342       {
68343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68344       };
68345     } catch (std::exception& e) {
68346       {
68347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68348       };
68349     } catch (...) {
68350       {
68351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68352       };
68353     }
68354   }
68355   jresult = result;
68356   return jresult;
68357 }
68358
68359
68360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68361   unsigned int jresult ;
68362   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68363   unsigned int result;
68364
68365   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68366   {
68367     try {
68368       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68369     } catch (std::out_of_range& e) {
68370       {
68371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68372       };
68373     } catch (std::exception& e) {
68374       {
68375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68376       };
68377     } catch (...) {
68378       {
68379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68380       };
68381     }
68382   }
68383   jresult = result;
68384   return jresult;
68385 }
68386
68387
68388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68389   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68390
68391   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68392   {
68393     try {
68394       delete arg1;
68395     } catch (std::out_of_range& e) {
68396       {
68397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68398       };
68399     } catch (std::exception& e) {
68400       {
68401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68402       };
68403     } catch (...) {
68404       {
68405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68406       };
68407     }
68408   }
68409 }
68410
68411
68412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68413   void * jresult ;
68414   float arg1 ;
68415   Dali::Toolkit::FixedRuler *result = 0 ;
68416
68417   arg1 = (float)jarg1;
68418   {
68419     try {
68420       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68421     } catch (std::out_of_range& e) {
68422       {
68423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (std::exception& e) {
68426       {
68427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68428       };
68429     } catch (...) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68432       };
68433     }
68434   }
68435   jresult = (void *)result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68441   void * jresult ;
68442   Dali::Toolkit::FixedRuler *result = 0 ;
68443
68444   {
68445     try {
68446       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68447     } catch (std::out_of_range& e) {
68448       {
68449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68450       };
68451     } catch (std::exception& e) {
68452       {
68453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68454       };
68455     } catch (...) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68458       };
68459     }
68460   }
68461   jresult = (void *)result;
68462   return jresult;
68463 }
68464
68465
68466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68467   float jresult ;
68468   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68469   float arg2 ;
68470   float arg3 ;
68471   float result;
68472
68473   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68474   arg2 = (float)jarg2;
68475   arg3 = (float)jarg3;
68476   {
68477     try {
68478       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68479     } catch (std::out_of_range& e) {
68480       {
68481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68482       };
68483     } catch (std::exception& e) {
68484       {
68485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68486       };
68487     } catch (...) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68490       };
68491     }
68492   }
68493   jresult = result;
68494   return jresult;
68495 }
68496
68497
68498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68499   float jresult ;
68500   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68501   unsigned int arg2 ;
68502   unsigned int *arg3 = 0 ;
68503   bool arg4 ;
68504   float result;
68505
68506   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68507   arg2 = (unsigned int)jarg2;
68508   arg3 = (unsigned int *)jarg3;
68509   arg4 = jarg4 ? true : false;
68510   {
68511     try {
68512       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68520       };
68521     } catch (...) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68524       };
68525     }
68526   }
68527   jresult = result;
68528   return jresult;
68529 }
68530
68531
68532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68533   unsigned int jresult ;
68534   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68535   float arg2 ;
68536   bool arg3 ;
68537   unsigned int result;
68538
68539   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68540   arg2 = (float)jarg2;
68541   arg3 = jarg3 ? true : false;
68542   {
68543     try {
68544       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68545     } catch (std::out_of_range& e) {
68546       {
68547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68548       };
68549     } catch (std::exception& e) {
68550       {
68551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (...) {
68554       {
68555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68556       };
68557     }
68558   }
68559   jresult = result;
68560   return jresult;
68561 }
68562
68563
68564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68565   unsigned int jresult ;
68566   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68567   unsigned int result;
68568
68569   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68570   {
68571     try {
68572       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68573     } catch (std::out_of_range& e) {
68574       {
68575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68576       };
68577     } catch (std::exception& e) {
68578       {
68579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68580       };
68581     } catch (...) {
68582       {
68583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68584       };
68585     }
68586   }
68587   jresult = result;
68588   return jresult;
68589 }
68590
68591
68592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68593   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68594
68595   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68596   {
68597     try {
68598       delete arg1;
68599     } catch (std::out_of_range& e) {
68600       {
68601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68602       };
68603     } catch (std::exception& e) {
68604       {
68605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68606       };
68607     } catch (...) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68610       };
68611     }
68612   }
68613 }
68614
68615
68616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68617   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68618   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68619
68620   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68621   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68622   if (arg1) (arg1)->scale = *arg2;
68623 }
68624
68625
68626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68627   void * jresult ;
68628   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68629   Dali::Toolkit::ClampState2D *result = 0 ;
68630
68631   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68632   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68633   jresult = (void *)result;
68634   return jresult;
68635 }
68636
68637
68638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68639   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68640   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68641
68642   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68643   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68644   if (arg1) (arg1)->position = *arg2;
68645 }
68646
68647
68648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68649   void * jresult ;
68650   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68651   Dali::Toolkit::ClampState2D *result = 0 ;
68652
68653   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68654   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68655   jresult = (void *)result;
68656   return jresult;
68657 }
68658
68659
68660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68661   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68662   Dali::Toolkit::ClampState arg2 ;
68663
68664   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68665   arg2 = (Dali::Toolkit::ClampState)jarg2;
68666   if (arg1) (arg1)->rotation = arg2;
68667 }
68668
68669
68670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68671   int jresult ;
68672   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68673   Dali::Toolkit::ClampState result;
68674
68675   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68676   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68677   jresult = (int)result;
68678   return jresult;
68679 }
68680
68681
68682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68683   void * jresult ;
68684   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68685
68686   {
68687     try {
68688       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68689     } catch (std::out_of_range& e) {
68690       {
68691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68692       };
68693     } catch (std::exception& e) {
68694       {
68695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68696       };
68697     } catch (...) {
68698       {
68699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68700       };
68701     }
68702   }
68703   jresult = (void *)result;
68704   return jresult;
68705 }
68706
68707
68708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68709   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68710
68711   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68712   {
68713     try {
68714       delete arg1;
68715     } catch (std::out_of_range& e) {
68716       {
68717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68718       };
68719     } catch (std::exception& e) {
68720       {
68721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68722       };
68723     } catch (...) {
68724       {
68725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68726       };
68727     }
68728   }
68729 }
68730
68731
68732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68733   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68734   Dali::Toolkit::SnapType arg2 ;
68735
68736   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68737   arg2 = (Dali::Toolkit::SnapType)jarg2;
68738   if (arg1) (arg1)->type = arg2;
68739 }
68740
68741
68742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68743   int jresult ;
68744   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68745   Dali::Toolkit::SnapType result;
68746
68747   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68748   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68749   jresult = (int)result;
68750   return jresult;
68751 }
68752
68753
68754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68755   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68756   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68757
68758   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68759   arg2 = (Dali::Vector2 *)jarg2;
68760   if (arg1) (arg1)->position = *arg2;
68761 }
68762
68763
68764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68765   void * jresult ;
68766   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68767   Dali::Vector2 *result = 0 ;
68768
68769   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68770   result = (Dali::Vector2 *)& ((arg1)->position);
68771   jresult = (void *)result;
68772   return jresult;
68773 }
68774
68775
68776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68777   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68778   float arg2 ;
68779
68780   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68781   arg2 = (float)jarg2;
68782   if (arg1) (arg1)->duration = arg2;
68783 }
68784
68785
68786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68787   float jresult ;
68788   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68789   float result;
68790
68791   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68792   result = (float) ((arg1)->duration);
68793   jresult = result;
68794   return jresult;
68795 }
68796
68797
68798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68799   void * jresult ;
68800   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68801
68802   {
68803     try {
68804       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68805     } catch (std::out_of_range& e) {
68806       {
68807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68808       };
68809     } catch (std::exception& e) {
68810       {
68811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68812       };
68813     } catch (...) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68816       };
68817     }
68818   }
68819   jresult = (void *)result;
68820   return jresult;
68821 }
68822
68823
68824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68825   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68826
68827   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68828   {
68829     try {
68830       delete arg1;
68831     } catch (std::out_of_range& e) {
68832       {
68833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68834       };
68835     } catch (std::exception& e) {
68836       {
68837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68838       };
68839     } catch (...) {
68840       {
68841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68842       };
68843     }
68844   }
68845 }
68846
68847
68848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68849   int jresult ;
68850   int result;
68851
68852   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68853   jresult = (int)result;
68854   return jresult;
68855 }
68856
68857
68858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68859   int jresult ;
68860   int result;
68861
68862   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68863   jresult = (int)result;
68864   return jresult;
68865 }
68866
68867
68868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68869   int jresult ;
68870   int result;
68871
68872   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68873   jresult = (int)result;
68874   return jresult;
68875 }
68876
68877
68878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68879   int jresult ;
68880   int result;
68881
68882   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68883   jresult = (int)result;
68884   return jresult;
68885 }
68886
68887
68888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68889   int jresult ;
68890   int result;
68891
68892   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
68893   jresult = (int)result;
68894   return jresult;
68895 }
68896
68897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68898   int jresult ;
68899   int result;
68900
68901   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68902   jresult = (int)result;
68903   return jresult;
68904 }
68905
68906
68907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68908   int jresult ;
68909   int result;
68910
68911   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68912   jresult = (int)result;
68913   return jresult;
68914 }
68915
68916
68917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68918   int jresult ;
68919   int result;
68920
68921   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68922   jresult = (int)result;
68923   return jresult;
68924 }
68925
68926
68927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68928   int jresult ;
68929   int result;
68930
68931   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68932   jresult = (int)result;
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68938   int jresult ;
68939   int result;
68940
68941   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68942   jresult = (int)result;
68943   return jresult;
68944 }
68945
68946
68947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68948   int jresult ;
68949   int result;
68950
68951   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68952   jresult = (int)result;
68953   return jresult;
68954 }
68955
68956
68957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68958   int jresult ;
68959   int result;
68960
68961   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68962   jresult = (int)result;
68963   return jresult;
68964 }
68965
68966
68967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68968   int jresult ;
68969   int result;
68970
68971   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68972   jresult = (int)result;
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68978   int jresult ;
68979   int result;
68980
68981   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68982   jresult = (int)result;
68983   return jresult;
68984 }
68985
68986
68987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68988   int jresult ;
68989   int result;
68990
68991   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68992   jresult = (int)result;
68993   return jresult;
68994 }
68995
68996
68997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68998   int jresult ;
68999   int result;
69000
69001   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
69002   jresult = (int)result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
69008   int jresult ;
69009   int result;
69010
69011   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
69012   jresult = (int)result;
69013   return jresult;
69014 }
69015
69016
69017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
69018   int jresult ;
69019   int result;
69020
69021   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
69022   jresult = (int)result;
69023   return jresult;
69024 }
69025
69026
69027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69028   int jresult ;
69029   int result;
69030
69031   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69032   jresult = (int)result;
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69038   int jresult ;
69039   int result;
69040
69041   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69042   jresult = (int)result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69048   int jresult ;
69049   int result;
69050
69051   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69052   jresult = (int)result;
69053   return jresult;
69054 }
69055
69056
69057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69058   int jresult ;
69059   int result;
69060
69061   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69062   jresult = (int)result;
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69068   int jresult ;
69069   int result;
69070
69071   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69072   jresult = (int)result;
69073   return jresult;
69074 }
69075
69076
69077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69078   int jresult ;
69079   int result;
69080
69081   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69082   jresult = (int)result;
69083   return jresult;
69084 }
69085
69086
69087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69088   int jresult ;
69089   int result;
69090
69091   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69092   jresult = (int)result;
69093   return jresult;
69094 }
69095
69096
69097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69098   int jresult ;
69099   int result;
69100
69101   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69102   jresult = (int)result;
69103   return jresult;
69104 }
69105
69106
69107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69108   void * jresult ;
69109   Dali::Toolkit::ScrollView::Property *result = 0 ;
69110
69111   {
69112     try {
69113       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69114     } catch (std::out_of_range& e) {
69115       {
69116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69117       };
69118     } catch (std::exception& e) {
69119       {
69120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69121       };
69122     } catch (...) {
69123       {
69124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69125       };
69126     }
69127   }
69128   jresult = (void *)result;
69129   return jresult;
69130 }
69131
69132
69133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69134   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69135
69136   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69137   {
69138     try {
69139       delete arg1;
69140     } catch (std::out_of_range& e) {
69141       {
69142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69143       };
69144     } catch (std::exception& e) {
69145       {
69146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69147       };
69148     } catch (...) {
69149       {
69150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69151       };
69152     }
69153   }
69154 }
69155
69156
69157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69158   void * jresult ;
69159   Dali::Toolkit::ScrollView *result = 0 ;
69160
69161   {
69162     try {
69163       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69164     } catch (std::out_of_range& e) {
69165       {
69166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69167       };
69168     } catch (std::exception& e) {
69169       {
69170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (...) {
69173       {
69174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69175       };
69176     }
69177   }
69178   jresult = (void *)result;
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69184   void * jresult ;
69185   Dali::Toolkit::ScrollView *arg1 = 0 ;
69186   Dali::Toolkit::ScrollView *result = 0 ;
69187
69188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69189   if (!arg1) {
69190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69191     return 0;
69192   }
69193   {
69194     try {
69195       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69196     } catch (std::out_of_range& e) {
69197       {
69198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69199       };
69200     } catch (std::exception& e) {
69201       {
69202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69203       };
69204     } catch (...) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69207       };
69208     }
69209   }
69210   jresult = (void *)result;
69211   return jresult;
69212 }
69213
69214
69215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69216   void * jresult ;
69217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69218   Dali::Toolkit::ScrollView *arg2 = 0 ;
69219   Dali::Toolkit::ScrollView *result = 0 ;
69220
69221   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69222   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69223   if (!arg2) {
69224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69225     return 0;
69226   }
69227   {
69228     try {
69229       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69230     } catch (std::out_of_range& e) {
69231       {
69232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69233       };
69234     } catch (std::exception& e) {
69235       {
69236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (...) {
69239       {
69240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69241       };
69242     }
69243   }
69244   jresult = (void *)result;
69245   return jresult;
69246 }
69247
69248
69249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69250   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69251
69252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69253   {
69254     try {
69255       delete arg1;
69256     } catch (std::out_of_range& e) {
69257       {
69258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (std::exception& e) {
69261       {
69262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69263       };
69264     } catch (...) {
69265       {
69266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69267       };
69268     }
69269   }
69270 }
69271
69272
69273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69274   void * jresult ;
69275   Dali::Toolkit::ScrollView result;
69276
69277   {
69278     try {
69279       result = Dali::Toolkit::ScrollView::New();
69280     } catch (std::out_of_range& e) {
69281       {
69282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69283       };
69284     } catch (std::exception& e) {
69285       {
69286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69291       };
69292     }
69293   }
69294   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69295   return jresult;
69296 }
69297
69298
69299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69300   void * jresult ;
69301   Dali::BaseHandle arg1 ;
69302   Dali::BaseHandle *argp1 ;
69303   Dali::Toolkit::ScrollView result;
69304
69305   argp1 = (Dali::BaseHandle *)jarg1;
69306   if (!argp1) {
69307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69308     return 0;
69309   }
69310   arg1 = *argp1;
69311   {
69312     try {
69313       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69314     } catch (std::out_of_range& e) {
69315       {
69316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69317       };
69318     } catch (std::exception& e) {
69319       {
69320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69321       };
69322     } catch (...) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69325       };
69326     }
69327   }
69328   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69329   return jresult;
69330 }
69331
69332
69333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69334   void * jresult ;
69335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69336   Dali::AlphaFunction result;
69337
69338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69339   {
69340     try {
69341       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (...) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69353       };
69354     }
69355   }
69356   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69357   return jresult;
69358 }
69359
69360
69361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69362   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69363   Dali::AlphaFunction arg2 ;
69364   Dali::AlphaFunction *argp2 ;
69365
69366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69367   argp2 = (Dali::AlphaFunction *)jarg2;
69368   if (!argp2) {
69369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69370     return ;
69371   }
69372   arg2 = *argp2;
69373   {
69374     try {
69375       (arg1)->SetScrollSnapAlphaFunction(arg2);
69376     } catch (std::out_of_range& e) {
69377       {
69378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69379       };
69380     } catch (std::exception& e) {
69381       {
69382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69383       };
69384     } catch (...) {
69385       {
69386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69387       };
69388     }
69389   }
69390 }
69391
69392
69393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69394   void * jresult ;
69395   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69396   Dali::AlphaFunction result;
69397
69398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69399   {
69400     try {
69401       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69402     } catch (std::out_of_range& e) {
69403       {
69404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69405       };
69406     } catch (std::exception& e) {
69407       {
69408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69409       };
69410     } catch (...) {
69411       {
69412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69413       };
69414     }
69415   }
69416   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69417   return jresult;
69418 }
69419
69420
69421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69423   Dali::AlphaFunction arg2 ;
69424   Dali::AlphaFunction *argp2 ;
69425
69426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69427   argp2 = (Dali::AlphaFunction *)jarg2;
69428   if (!argp2) {
69429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69430     return ;
69431   }
69432   arg2 = *argp2;
69433   {
69434     try {
69435       (arg1)->SetScrollFlickAlphaFunction(arg2);
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69443       };
69444     } catch (...) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69447       };
69448     }
69449   }
69450 }
69451
69452
69453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69454   float jresult ;
69455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69456   float result;
69457
69458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69459   {
69460     try {
69461       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69462     } catch (std::out_of_range& e) {
69463       {
69464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69465       };
69466     } catch (std::exception& e) {
69467       {
69468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69469       };
69470     } catch (...) {
69471       {
69472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69473       };
69474     }
69475   }
69476   jresult = result;
69477   return jresult;
69478 }
69479
69480
69481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69482   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69483   float arg2 ;
69484
69485   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69486   arg2 = (float)jarg2;
69487   {
69488     try {
69489       (arg1)->SetScrollSnapDuration(arg2);
69490     } catch (std::out_of_range& e) {
69491       {
69492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69493       };
69494     } catch (std::exception& e) {
69495       {
69496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69501       };
69502     }
69503   }
69504 }
69505
69506
69507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69508   float jresult ;
69509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69510   float result;
69511
69512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69513   {
69514     try {
69515       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69516     } catch (std::out_of_range& e) {
69517       {
69518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69519       };
69520     } catch (std::exception& e) {
69521       {
69522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69523       };
69524     } catch (...) {
69525       {
69526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69527       };
69528     }
69529   }
69530   jresult = result;
69531   return jresult;
69532 }
69533
69534
69535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69536   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69537   float arg2 ;
69538
69539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69540   arg2 = (float)jarg2;
69541   {
69542     try {
69543       (arg1)->SetScrollFlickDuration(arg2);
69544     } catch (std::out_of_range& e) {
69545       {
69546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69547       };
69548     } catch (std::exception& e) {
69549       {
69550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69551       };
69552     } catch (...) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69555       };
69556     }
69557   }
69558 }
69559
69560
69561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69563   Dali::Toolkit::RulerPtr arg2 ;
69564   Dali::Toolkit::RulerPtr *argp2 ;
69565
69566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69567   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69568   if (!argp2) {
69569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69570     return ;
69571   }
69572   arg2 = *argp2;
69573   {
69574     try {
69575       (arg1)->SetRulerX(arg2);
69576     } catch (std::out_of_range& e) {
69577       {
69578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69579       };
69580     } catch (std::exception& e) {
69581       {
69582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69583       };
69584     } catch (...) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69587       };
69588     }
69589   }
69590 }
69591
69592
69593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69595   Dali::Toolkit::RulerPtr arg2 ;
69596   Dali::Toolkit::RulerPtr *argp2 ;
69597
69598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69599   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69600   if (!argp2) {
69601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69602     return ;
69603   }
69604   arg2 = *argp2;
69605   {
69606     try {
69607       (arg1)->SetRulerY(arg2);
69608     } catch (std::out_of_range& e) {
69609       {
69610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69611       };
69612     } catch (std::exception& e) {
69613       {
69614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69619       };
69620     }
69621   }
69622 }
69623
69624
69625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69627   bool arg2 ;
69628
69629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69630   arg2 = jarg2 ? true : false;
69631   {
69632     try {
69633       (arg1)->SetScrollSensitive(arg2);
69634     } catch (std::out_of_range& e) {
69635       {
69636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69637       };
69638     } catch (std::exception& e) {
69639       {
69640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69641       };
69642     } catch (...) {
69643       {
69644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69645       };
69646     }
69647   }
69648 }
69649
69650
69651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69652   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69653   float arg2 ;
69654   float arg3 ;
69655
69656   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69657   arg2 = (float)jarg2;
69658   arg3 = (float)jarg3;
69659   {
69660     try {
69661       (arg1)->SetMaxOvershoot(arg2,arg3);
69662     } catch (std::out_of_range& e) {
69663       {
69664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69665       };
69666     } catch (std::exception& e) {
69667       {
69668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69669       };
69670     } catch (...) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69673       };
69674     }
69675   }
69676 }
69677
69678
69679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69680   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69681   Dali::AlphaFunction arg2 ;
69682   Dali::AlphaFunction *argp2 ;
69683
69684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69685   argp2 = (Dali::AlphaFunction *)jarg2;
69686   if (!argp2) {
69687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69688     return ;
69689   }
69690   arg2 = *argp2;
69691   {
69692     try {
69693       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69694     } catch (std::out_of_range& e) {
69695       {
69696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69697       };
69698     } catch (std::exception& e) {
69699       {
69700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69701       };
69702     } catch (...) {
69703       {
69704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69705       };
69706     }
69707   }
69708 }
69709
69710
69711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69712   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69713   float arg2 ;
69714
69715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69716   arg2 = (float)jarg2;
69717   {
69718     try {
69719       (arg1)->SetSnapOvershootDuration(arg2);
69720     } catch (std::out_of_range& e) {
69721       {
69722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69723       };
69724     } catch (std::exception& e) {
69725       {
69726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69727       };
69728     } catch (...) {
69729       {
69730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69731       };
69732     }
69733   }
69734 }
69735
69736
69737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69739   bool arg2 ;
69740
69741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69742   arg2 = jarg2 ? true : false;
69743   {
69744     try {
69745       (arg1)->SetActorAutoSnap(arg2);
69746     } catch (std::out_of_range& e) {
69747       {
69748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69749       };
69750     } catch (std::exception& e) {
69751       {
69752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69753       };
69754     } catch (...) {
69755       {
69756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69757       };
69758     }
69759   }
69760 }
69761
69762
69763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69765   bool arg2 ;
69766
69767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69768   arg2 = jarg2 ? true : false;
69769   {
69770     try {
69771       (arg1)->SetWrapMode(arg2);
69772     } catch (std::out_of_range& e) {
69773       {
69774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69775       };
69776     } catch (std::exception& e) {
69777       {
69778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69779       };
69780     } catch (...) {
69781       {
69782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69783       };
69784     }
69785   }
69786 }
69787
69788
69789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69790   int jresult ;
69791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69792   int result;
69793
69794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69795   {
69796     try {
69797       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69798     } catch (std::out_of_range& e) {
69799       {
69800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69801       };
69802     } catch (std::exception& e) {
69803       {
69804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (...) {
69807       {
69808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69809       };
69810     }
69811   }
69812   jresult = result;
69813   return jresult;
69814 }
69815
69816
69817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69819   int arg2 ;
69820
69821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69822   arg2 = (int)jarg2;
69823   {
69824     try {
69825       (arg1)->SetScrollUpdateDistance(arg2);
69826     } catch (std::out_of_range& e) {
69827       {
69828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69829       };
69830     } catch (std::exception& e) {
69831       {
69832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69833       };
69834     } catch (...) {
69835       {
69836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69837       };
69838     }
69839   }
69840 }
69841
69842
69843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69844   unsigned int jresult ;
69845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69846   bool result;
69847
69848   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69849   {
69850     try {
69851       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69852     } catch (std::out_of_range& e) {
69853       {
69854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (std::exception& e) {
69857       {
69858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69863       };
69864     }
69865   }
69866   jresult = result;
69867   return jresult;
69868 }
69869
69870
69871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69872   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69873   bool arg2 ;
69874
69875   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69876   arg2 = jarg2 ? true : false;
69877   {
69878     try {
69879       (arg1)->SetAxisAutoLock(arg2);
69880     } catch (std::out_of_range& e) {
69881       {
69882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69883       };
69884     } catch (std::exception& e) {
69885       {
69886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69887       };
69888     } catch (...) {
69889       {
69890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69891       };
69892     }
69893   }
69894 }
69895
69896
69897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69898   float jresult ;
69899   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69900   float result;
69901
69902   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69903   {
69904     try {
69905       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69906     } catch (std::out_of_range& e) {
69907       {
69908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69909       };
69910     } catch (std::exception& e) {
69911       {
69912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69913       };
69914     } catch (...) {
69915       {
69916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69917       };
69918     }
69919   }
69920   jresult = result;
69921   return jresult;
69922 }
69923
69924
69925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69927   float arg2 ;
69928
69929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69930   arg2 = (float)jarg2;
69931   {
69932     try {
69933       (arg1)->SetAxisAutoLockGradient(arg2);
69934     } catch (std::out_of_range& e) {
69935       {
69936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69937       };
69938     } catch (std::exception& e) {
69939       {
69940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69941       };
69942     } catch (...) {
69943       {
69944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69945       };
69946     }
69947   }
69948 }
69949
69950
69951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69952   float jresult ;
69953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69954   float result;
69955
69956   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69957   {
69958     try {
69959       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69960     } catch (std::out_of_range& e) {
69961       {
69962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69963       };
69964     } catch (std::exception& e) {
69965       {
69966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69967       };
69968     } catch (...) {
69969       {
69970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69971       };
69972     }
69973   }
69974   jresult = result;
69975   return jresult;
69976 }
69977
69978
69979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69981   float arg2 ;
69982
69983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69984   arg2 = (float)jarg2;
69985   {
69986     try {
69987       (arg1)->SetFrictionCoefficient(arg2);
69988     } catch (std::out_of_range& e) {
69989       {
69990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69991       };
69992     } catch (std::exception& e) {
69993       {
69994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69995       };
69996     } catch (...) {
69997       {
69998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69999       };
70000     }
70001   }
70002 }
70003
70004
70005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
70006   float jresult ;
70007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70008   float result;
70009
70010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70011   {
70012     try {
70013       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
70014     } catch (std::out_of_range& e) {
70015       {
70016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (std::exception& e) {
70019       {
70020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70021       };
70022     } catch (...) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70025       };
70026     }
70027   }
70028   jresult = result;
70029   return jresult;
70030 }
70031
70032
70033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70034   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70035   float arg2 ;
70036
70037   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70038   arg2 = (float)jarg2;
70039   {
70040     try {
70041       (arg1)->SetFlickSpeedCoefficient(arg2);
70042     } catch (std::out_of_range& e) {
70043       {
70044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70045       };
70046     } catch (std::exception& e) {
70047       {
70048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70049       };
70050     } catch (...) {
70051       {
70052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70053       };
70054     }
70055   }
70056 }
70057
70058
70059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70060   void * jresult ;
70061   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70062   Dali::Vector2 result;
70063
70064   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70065   {
70066     try {
70067       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70068     } catch (std::out_of_range& e) {
70069       {
70070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70071       };
70072     } catch (std::exception& e) {
70073       {
70074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70075       };
70076     } catch (...) {
70077       {
70078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70079       };
70080     }
70081   }
70082   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70083   return jresult;
70084 }
70085
70086
70087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70089   Dali::Vector2 *arg2 = 0 ;
70090
70091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70092   arg2 = (Dali::Vector2 *)jarg2;
70093   if (!arg2) {
70094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70095     return ;
70096   }
70097   {
70098     try {
70099       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70100     } catch (std::out_of_range& e) {
70101       {
70102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70103       };
70104     } catch (std::exception& e) {
70105       {
70106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70107       };
70108     } catch (...) {
70109       {
70110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70111       };
70112     }
70113   }
70114 }
70115
70116
70117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70118   float jresult ;
70119   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70120   float result;
70121
70122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70123   {
70124     try {
70125       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70126     } catch (std::out_of_range& e) {
70127       {
70128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70129       };
70130     } catch (std::exception& e) {
70131       {
70132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70133       };
70134     } catch (...) {
70135       {
70136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70137       };
70138     }
70139   }
70140   jresult = result;
70141   return jresult;
70142 }
70143
70144
70145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70147   float arg2 ;
70148
70149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70150   arg2 = (float)jarg2;
70151   {
70152     try {
70153       (arg1)->SetMinimumSpeedForFlick(arg2);
70154     } catch (std::out_of_range& e) {
70155       {
70156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70157       };
70158     } catch (std::exception& e) {
70159       {
70160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70161       };
70162     } catch (...) {
70163       {
70164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70165       };
70166     }
70167   }
70168 }
70169
70170
70171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70172   float jresult ;
70173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70174   float result;
70175
70176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70177   {
70178     try {
70179       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70180     } catch (std::out_of_range& e) {
70181       {
70182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70183       };
70184     } catch (std::exception& e) {
70185       {
70186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70187       };
70188     } catch (...) {
70189       {
70190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70191       };
70192     }
70193   }
70194   jresult = result;
70195   return jresult;
70196 }
70197
70198
70199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70200   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70201   float arg2 ;
70202
70203   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70204   arg2 = (float)jarg2;
70205   {
70206     try {
70207       (arg1)->SetMaxFlickSpeed(arg2);
70208     } catch (std::out_of_range& e) {
70209       {
70210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70211       };
70212     } catch (std::exception& e) {
70213       {
70214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70215       };
70216     } catch (...) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70219       };
70220     }
70221   }
70222 }
70223
70224
70225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70226   void * jresult ;
70227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70228   Dali::Vector2 result;
70229
70230   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70231   {
70232     try {
70233       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70234     } catch (std::out_of_range& e) {
70235       {
70236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70237       };
70238     } catch (std::exception& e) {
70239       {
70240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70241       };
70242     } catch (...) {
70243       {
70244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70245       };
70246     }
70247   }
70248   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70249   return jresult;
70250 }
70251
70252
70253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70254   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70255   Dali::Vector2 arg2 ;
70256   Dali::Vector2 *argp2 ;
70257
70258   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70259   argp2 = (Dali::Vector2 *)jarg2;
70260   if (!argp2) {
70261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70262     return ;
70263   }
70264   arg2 = *argp2;
70265   {
70266     try {
70267       (arg1)->SetWheelScrollDistanceStep(arg2);
70268     } catch (std::out_of_range& e) {
70269       {
70270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70271       };
70272     } catch (std::exception& e) {
70273       {
70274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70275       };
70276     } catch (...) {
70277       {
70278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70279       };
70280     }
70281   }
70282 }
70283
70284
70285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70286   void * jresult ;
70287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70288   Dali::Vector2 result;
70289
70290   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70291   {
70292     try {
70293       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70294     } catch (std::out_of_range& e) {
70295       {
70296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70297       };
70298     } catch (std::exception& e) {
70299       {
70300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70301       };
70302     } catch (...) {
70303       {
70304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70305       };
70306     }
70307   }
70308   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70309   return jresult;
70310 }
70311
70312
70313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70314   unsigned int jresult ;
70315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70316   unsigned int result;
70317
70318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70319   {
70320     try {
70321       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70322     } catch (std::out_of_range& e) {
70323       {
70324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70325       };
70326     } catch (std::exception& e) {
70327       {
70328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70329       };
70330     } catch (...) {
70331       {
70332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70333       };
70334     }
70335   }
70336   jresult = result;
70337   return jresult;
70338 }
70339
70340
70341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70343   Dali::Vector2 *arg2 = 0 ;
70344
70345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70346   arg2 = (Dali::Vector2 *)jarg2;
70347   if (!arg2) {
70348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70349     return ;
70350   }
70351   {
70352     try {
70353       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70354     } catch (std::out_of_range& e) {
70355       {
70356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70357       };
70358     } catch (std::exception& e) {
70359       {
70360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70361       };
70362     } catch (...) {
70363       {
70364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70365       };
70366     }
70367   }
70368 }
70369
70370
70371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70372   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70373   Dali::Vector2 *arg2 = 0 ;
70374   float arg3 ;
70375
70376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70377   arg2 = (Dali::Vector2 *)jarg2;
70378   if (!arg2) {
70379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70380     return ;
70381   }
70382   arg3 = (float)jarg3;
70383   {
70384     try {
70385       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70386     } catch (std::out_of_range& e) {
70387       {
70388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70389       };
70390     } catch (std::exception& e) {
70391       {
70392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70393       };
70394     } catch (...) {
70395       {
70396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70397       };
70398     }
70399   }
70400 }
70401
70402
70403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70405   Dali::Vector2 *arg2 = 0 ;
70406   float arg3 ;
70407   Dali::AlphaFunction arg4 ;
70408   Dali::AlphaFunction *argp4 ;
70409
70410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70411   arg2 = (Dali::Vector2 *)jarg2;
70412   if (!arg2) {
70413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70414     return ;
70415   }
70416   arg3 = (float)jarg3;
70417   argp4 = (Dali::AlphaFunction *)jarg4;
70418   if (!argp4) {
70419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70420     return ;
70421   }
70422   arg4 = *argp4;
70423   {
70424     try {
70425       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70437       };
70438     }
70439   }
70440 }
70441
70442
70443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70444   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70445   Dali::Vector2 *arg2 = 0 ;
70446   float arg3 ;
70447   Dali::Toolkit::DirectionBias arg4 ;
70448   Dali::Toolkit::DirectionBias arg5 ;
70449
70450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70451   arg2 = (Dali::Vector2 *)jarg2;
70452   if (!arg2) {
70453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70454     return ;
70455   }
70456   arg3 = (float)jarg3;
70457   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70458   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70459   {
70460     try {
70461       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70462     } catch (std::out_of_range& e) {
70463       {
70464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (std::exception& e) {
70467       {
70468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70473       };
70474     }
70475   }
70476 }
70477
70478
70479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70481   Dali::Vector2 *arg2 = 0 ;
70482   float arg3 ;
70483   Dali::AlphaFunction arg4 ;
70484   Dali::Toolkit::DirectionBias arg5 ;
70485   Dali::Toolkit::DirectionBias arg6 ;
70486   Dali::AlphaFunction *argp4 ;
70487
70488   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70489   arg2 = (Dali::Vector2 *)jarg2;
70490   if (!arg2) {
70491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70492     return ;
70493   }
70494   arg3 = (float)jarg3;
70495   argp4 = (Dali::AlphaFunction *)jarg4;
70496   if (!argp4) {
70497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70498     return ;
70499   }
70500   arg4 = *argp4;
70501   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70502   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70503   {
70504     try {
70505       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70506     } catch (std::out_of_range& e) {
70507       {
70508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70509       };
70510     } catch (std::exception& e) {
70511       {
70512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70513       };
70514     } catch (...) {
70515       {
70516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70517       };
70518     }
70519   }
70520 }
70521
70522
70523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70525   unsigned int arg2 ;
70526
70527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70528   arg2 = (unsigned int)jarg2;
70529   {
70530     try {
70531       (arg1)->ScrollTo(arg2);
70532     } catch (std::out_of_range& e) {
70533       {
70534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70535       };
70536     } catch (std::exception& e) {
70537       {
70538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70539       };
70540     } catch (...) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70543       };
70544     }
70545   }
70546 }
70547
70548
70549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70551   unsigned int arg2 ;
70552   float arg3 ;
70553
70554   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70555   arg2 = (unsigned int)jarg2;
70556   arg3 = (float)jarg3;
70557   {
70558     try {
70559       (arg1)->ScrollTo(arg2,arg3);
70560     } catch (std::out_of_range& e) {
70561       {
70562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70563       };
70564     } catch (std::exception& e) {
70565       {
70566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70567       };
70568     } catch (...) {
70569       {
70570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70571       };
70572     }
70573   }
70574 }
70575
70576
70577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70579   unsigned int arg2 ;
70580   float arg3 ;
70581   Dali::Toolkit::DirectionBias arg4 ;
70582
70583   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70584   arg2 = (unsigned int)jarg2;
70585   arg3 = (float)jarg3;
70586   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70587   {
70588     try {
70589       (arg1)->ScrollTo(arg2,arg3,arg4);
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (...) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70601       };
70602     }
70603   }
70604 }
70605
70606
70607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70609   Dali::Actor *arg2 = 0 ;
70610
70611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70612   arg2 = (Dali::Actor *)jarg2;
70613   if (!arg2) {
70614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70615     return ;
70616   }
70617   {
70618     try {
70619       (arg1)->ScrollTo(*arg2);
70620     } catch (std::out_of_range& e) {
70621       {
70622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70623       };
70624     } catch (std::exception& e) {
70625       {
70626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70631       };
70632     }
70633   }
70634 }
70635
70636
70637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70639   Dali::Actor *arg2 = 0 ;
70640   float arg3 ;
70641
70642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70643   arg2 = (Dali::Actor *)jarg2;
70644   if (!arg2) {
70645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70646     return ;
70647   }
70648   arg3 = (float)jarg3;
70649   {
70650     try {
70651       (arg1)->ScrollTo(*arg2,arg3);
70652     } catch (std::out_of_range& e) {
70653       {
70654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70655       };
70656     } catch (std::exception& e) {
70657       {
70658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70659       };
70660     } catch (...) {
70661       {
70662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70663       };
70664     }
70665   }
70666 }
70667
70668
70669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70670   unsigned int jresult ;
70671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70672   bool result;
70673
70674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70675   {
70676     try {
70677       result = (bool)(arg1)->ScrollToSnapPoint();
70678     } catch (std::out_of_range& e) {
70679       {
70680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70681       };
70682     } catch (std::exception& e) {
70683       {
70684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70685       };
70686     } catch (...) {
70687       {
70688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70689       };
70690     }
70691   }
70692   jresult = result;
70693   return jresult;
70694 }
70695
70696
70697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70699   Dali::Constraint arg2 ;
70700   Dali::Constraint *argp2 ;
70701
70702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70703   argp2 = (Dali::Constraint *)jarg2;
70704   if (!argp2) {
70705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70706     return ;
70707   }
70708   arg2 = *argp2;
70709   {
70710     try {
70711       (arg1)->ApplyConstraintToChildren(arg2);
70712     } catch (std::out_of_range& e) {
70713       {
70714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70715       };
70716     } catch (std::exception& e) {
70717       {
70718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70719       };
70720     } catch (...) {
70721       {
70722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70723       };
70724     }
70725   }
70726 }
70727
70728
70729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70730   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70731
70732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70733   {
70734     try {
70735       (arg1)->RemoveConstraintsFromChildren();
70736     } catch (std::out_of_range& e) {
70737       {
70738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70739       };
70740     } catch (std::exception& e) {
70741       {
70742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70743       };
70744     } catch (...) {
70745       {
70746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70747       };
70748     }
70749   }
70750 }
70751
70752
70753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70754   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70755   Dali::Toolkit::ScrollViewEffect arg2 ;
70756   Dali::Toolkit::ScrollViewEffect *argp2 ;
70757
70758   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70759   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70760   if (!argp2) {
70761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70762     return ;
70763   }
70764   arg2 = *argp2;
70765   {
70766     try {
70767       (arg1)->ApplyEffect(arg2);
70768     } catch (std::out_of_range& e) {
70769       {
70770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70771       };
70772     } catch (std::exception& e) {
70773       {
70774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70775       };
70776     } catch (...) {
70777       {
70778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70779       };
70780     }
70781   }
70782 }
70783
70784
70785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70786   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70787   Dali::Toolkit::ScrollViewEffect arg2 ;
70788   Dali::Toolkit::ScrollViewEffect *argp2 ;
70789
70790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70791   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70792   if (!argp2) {
70793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70794     return ;
70795   }
70796   arg2 = *argp2;
70797   {
70798     try {
70799       (arg1)->RemoveEffect(arg2);
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (...) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70811       };
70812     }
70813   }
70814 }
70815
70816
70817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70819
70820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70821   {
70822     try {
70823       (arg1)->RemoveAllEffects();
70824     } catch (std::out_of_range& e) {
70825       {
70826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70827       };
70828     } catch (std::exception& e) {
70829       {
70830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70831       };
70832     } catch (...) {
70833       {
70834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70835       };
70836     }
70837   }
70838 }
70839
70840
70841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70843   Dali::Actor arg2 ;
70844   Dali::Actor *argp2 ;
70845
70846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70847   argp2 = (Dali::Actor *)jarg2;
70848   if (!argp2) {
70849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70850     return ;
70851   }
70852   arg2 = *argp2;
70853   {
70854     try {
70855       (arg1)->BindActor(arg2);
70856     } catch (std::out_of_range& e) {
70857       {
70858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70859       };
70860     } catch (std::exception& e) {
70861       {
70862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70863       };
70864     } catch (...) {
70865       {
70866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70867       };
70868     }
70869   }
70870 }
70871
70872
70873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70874   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70875   Dali::Actor arg2 ;
70876   Dali::Actor *argp2 ;
70877
70878   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70879   argp2 = (Dali::Actor *)jarg2;
70880   if (!argp2) {
70881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70882     return ;
70883   }
70884   arg2 = *argp2;
70885   {
70886     try {
70887       (arg1)->UnbindActor(arg2);
70888     } catch (std::out_of_range& e) {
70889       {
70890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70891       };
70892     } catch (std::exception& e) {
70893       {
70894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70895       };
70896     } catch (...) {
70897       {
70898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70899       };
70900     }
70901   }
70902 }
70903
70904
70905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70907   Dali::Radian arg2 ;
70908   Dali::Radian arg3 ;
70909   Dali::Radian *argp2 ;
70910   Dali::Radian *argp3 ;
70911
70912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70913   argp2 = (Dali::Radian *)jarg2;
70914   if (!argp2) {
70915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70916     return ;
70917   }
70918   arg2 = *argp2;
70919   argp3 = (Dali::Radian *)jarg3;
70920   if (!argp3) {
70921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70922     return ;
70923   }
70924   arg3 = *argp3;
70925   {
70926     try {
70927       (arg1)->SetScrollingDirection(arg2,arg3);
70928     } catch (std::out_of_range& e) {
70929       {
70930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70931       };
70932     } catch (std::exception& e) {
70933       {
70934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70935       };
70936     } catch (...) {
70937       {
70938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70939       };
70940     }
70941   }
70942 }
70943
70944
70945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70947   Dali::Radian arg2 ;
70948   Dali::Radian *argp2 ;
70949
70950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70951   argp2 = (Dali::Radian *)jarg2;
70952   if (!argp2) {
70953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70954     return ;
70955   }
70956   arg2 = *argp2;
70957   {
70958     try {
70959       (arg1)->SetScrollingDirection(arg2);
70960     } catch (std::out_of_range& e) {
70961       {
70962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70963       };
70964     } catch (std::exception& e) {
70965       {
70966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70967       };
70968     } catch (...) {
70969       {
70970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70971       };
70972     }
70973   }
70974 }
70975
70976
70977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70979   Dali::Radian arg2 ;
70980   Dali::Radian *argp2 ;
70981
70982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70983   argp2 = (Dali::Radian *)jarg2;
70984   if (!argp2) {
70985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70986     return ;
70987   }
70988   arg2 = *argp2;
70989   {
70990     try {
70991       (arg1)->RemoveScrollingDirection(arg2);
70992     } catch (std::out_of_range& e) {
70993       {
70994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70995       };
70996     } catch (std::exception& e) {
70997       {
70998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70999       };
71000     } catch (...) {
71001       {
71002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71003       };
71004     }
71005   }
71006 }
71007
71008
71009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
71010   void * jresult ;
71011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71012   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
71013
71014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71015   {
71016     try {
71017       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
71018     } catch (std::out_of_range& e) {
71019       {
71020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (std::exception& e) {
71023       {
71024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71025       };
71026     } catch (...) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71029       };
71030     }
71031   }
71032   jresult = (void *)result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71038   int jresult ;
71039   int result;
71040
71041   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71042   jresult = (int)result;
71043   return jresult;
71044 }
71045
71046
71047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71048   int jresult ;
71049   int result;
71050
71051   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71052   jresult = (int)result;
71053   return jresult;
71054 }
71055
71056
71057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71058   int jresult ;
71059   int result;
71060
71061   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71062   jresult = (int)result;
71063   return jresult;
71064 }
71065
71066
71067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71068   int jresult ;
71069   int result;
71070
71071   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71072   jresult = (int)result;
71073   return jresult;
71074 }
71075
71076
71077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71078   int jresult ;
71079   int result;
71080
71081   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71082   jresult = (int)result;
71083   return jresult;
71084 }
71085
71086
71087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71088   void * jresult ;
71089   Dali::Toolkit::TableView::Property *result = 0 ;
71090
71091   {
71092     try {
71093       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71094     } catch (std::out_of_range& e) {
71095       {
71096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71097       };
71098     } catch (std::exception& e) {
71099       {
71100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71101       };
71102     } catch (...) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71105       };
71106     }
71107   }
71108   jresult = (void *)result;
71109   return jresult;
71110 }
71111
71112
71113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71114   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71115
71116   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71117   {
71118     try {
71119       delete arg1;
71120     } catch (std::out_of_range& e) {
71121       {
71122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71123       };
71124     } catch (std::exception& e) {
71125       {
71126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71127       };
71128     } catch (...) {
71129       {
71130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71131       };
71132     }
71133   }
71134 }
71135
71136
71137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71138   int jresult ;
71139   int result;
71140
71141   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71142   jresult = (int)result;
71143   return jresult;
71144 }
71145
71146
71147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71148   int jresult ;
71149   int result;
71150
71151   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71152   jresult = (int)result;
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71158   int jresult ;
71159   int result;
71160
71161   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71162   jresult = (int)result;
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71168   int jresult ;
71169   int result;
71170
71171   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71172   jresult = (int)result;
71173   return jresult;
71174 }
71175
71176
71177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71178   int jresult ;
71179   int result;
71180
71181   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71182   jresult = (int)result;
71183   return jresult;
71184 }
71185
71186
71187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71188   void * jresult ;
71189   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71190
71191   {
71192     try {
71193       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71194     } catch (std::out_of_range& e) {
71195       {
71196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71197       };
71198     } catch (std::exception& e) {
71199       {
71200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71201       };
71202     } catch (...) {
71203       {
71204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71205       };
71206     }
71207   }
71208   jresult = (void *)result;
71209   return jresult;
71210 }
71211
71212
71213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71214   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71215
71216   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71217   {
71218     try {
71219       delete arg1;
71220     } catch (std::out_of_range& e) {
71221       {
71222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71223       };
71224     } catch (std::exception& e) {
71225       {
71226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71227       };
71228     } catch (...) {
71229       {
71230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71231       };
71232     }
71233   }
71234 }
71235
71236
71237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71238   void * jresult ;
71239   unsigned int arg1 ;
71240   unsigned int arg2 ;
71241   unsigned int arg3 ;
71242   unsigned int arg4 ;
71243   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71244
71245   arg1 = (unsigned int)jarg1;
71246   arg2 = (unsigned int)jarg2;
71247   arg3 = (unsigned int)jarg3;
71248   arg4 = (unsigned int)jarg4;
71249   {
71250     try {
71251       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71252     } catch (std::out_of_range& e) {
71253       {
71254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71255       };
71256     } catch (std::exception& e) {
71257       {
71258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71259       };
71260     } catch (...) {
71261       {
71262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71263       };
71264     }
71265   }
71266   jresult = (void *)result;
71267   return jresult;
71268 }
71269
71270
71271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71272   void * jresult ;
71273   unsigned int arg1 ;
71274   unsigned int arg2 ;
71275   unsigned int arg3 ;
71276   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71277
71278   arg1 = (unsigned int)jarg1;
71279   arg2 = (unsigned int)jarg2;
71280   arg3 = (unsigned int)jarg3;
71281   {
71282     try {
71283       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71284     } catch (std::out_of_range& e) {
71285       {
71286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71287       };
71288     } catch (std::exception& e) {
71289       {
71290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71291       };
71292     } catch (...) {
71293       {
71294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71295       };
71296     }
71297   }
71298   jresult = (void *)result;
71299   return jresult;
71300 }
71301
71302
71303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71304   void * jresult ;
71305   unsigned int arg1 ;
71306   unsigned int arg2 ;
71307   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71308
71309   arg1 = (unsigned int)jarg1;
71310   arg2 = (unsigned int)jarg2;
71311   {
71312     try {
71313       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71314     } catch (std::out_of_range& e) {
71315       {
71316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71317       };
71318     } catch (std::exception& e) {
71319       {
71320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71321       };
71322     } catch (...) {
71323       {
71324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71325       };
71326     }
71327   }
71328   jresult = (void *)result;
71329   return jresult;
71330 }
71331
71332
71333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71334   void * jresult ;
71335   unsigned int arg1 ;
71336   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71337
71338   arg1 = (unsigned int)jarg1;
71339   {
71340     try {
71341       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71342     } catch (std::out_of_range& e) {
71343       {
71344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71345       };
71346     } catch (std::exception& e) {
71347       {
71348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71349       };
71350     } catch (...) {
71351       {
71352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71353       };
71354     }
71355   }
71356   jresult = (void *)result;
71357   return jresult;
71358 }
71359
71360
71361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71362   void * jresult ;
71363   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71364
71365   {
71366     try {
71367       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71368     } catch (std::out_of_range& e) {
71369       {
71370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71371       };
71372     } catch (std::exception& e) {
71373       {
71374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71375       };
71376     } catch (...) {
71377       {
71378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71379       };
71380     }
71381   }
71382   jresult = (void *)result;
71383   return jresult;
71384 }
71385
71386
71387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71388   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71389   unsigned int arg2 ;
71390
71391   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71392   arg2 = (unsigned int)jarg2;
71393   if (arg1) (arg1)->rowIndex = arg2;
71394 }
71395
71396
71397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71398   unsigned int jresult ;
71399   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71400   unsigned int result;
71401
71402   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71403   result = (unsigned int) ((arg1)->rowIndex);
71404   jresult = result;
71405   return jresult;
71406 }
71407
71408
71409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71410   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71411   unsigned int arg2 ;
71412
71413   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71414   arg2 = (unsigned int)jarg2;
71415   if (arg1) (arg1)->columnIndex = arg2;
71416 }
71417
71418
71419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71420   unsigned int jresult ;
71421   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71422   unsigned int result;
71423
71424   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71425   result = (unsigned int) ((arg1)->columnIndex);
71426   jresult = result;
71427   return jresult;
71428 }
71429
71430
71431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71432   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71433   unsigned int arg2 ;
71434
71435   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71436   arg2 = (unsigned int)jarg2;
71437   if (arg1) (arg1)->rowSpan = arg2;
71438 }
71439
71440
71441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71442   unsigned int jresult ;
71443   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71444   unsigned int result;
71445
71446   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71447   result = (unsigned int) ((arg1)->rowSpan);
71448   jresult = result;
71449   return jresult;
71450 }
71451
71452
71453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71454   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71455   unsigned int arg2 ;
71456
71457   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71458   arg2 = (unsigned int)jarg2;
71459   if (arg1) (arg1)->columnSpan = arg2;
71460 }
71461
71462
71463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71464   unsigned int jresult ;
71465   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71466   unsigned int result;
71467
71468   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71469   result = (unsigned int) ((arg1)->columnSpan);
71470   jresult = result;
71471   return jresult;
71472 }
71473
71474
71475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71476   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71477
71478   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71479   {
71480     try {
71481       delete arg1;
71482     } catch (std::out_of_range& e) {
71483       {
71484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71485       };
71486     } catch (std::exception& e) {
71487       {
71488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71489       };
71490     } catch (...) {
71491       {
71492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71493       };
71494     }
71495   }
71496 }
71497
71498
71499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71500   void * jresult ;
71501   Dali::Toolkit::TableView *result = 0 ;
71502
71503   {
71504     try {
71505       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71506     } catch (std::out_of_range& e) {
71507       {
71508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71509       };
71510     } catch (std::exception& e) {
71511       {
71512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71513       };
71514     } catch (...) {
71515       {
71516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71517       };
71518     }
71519   }
71520   jresult = (void *)result;
71521   return jresult;
71522 }
71523
71524
71525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71526   void * jresult ;
71527   Dali::Toolkit::TableView *arg1 = 0 ;
71528   Dali::Toolkit::TableView *result = 0 ;
71529
71530   arg1 = (Dali::Toolkit::TableView *)jarg1;
71531   if (!arg1) {
71532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71533     return 0;
71534   }
71535   {
71536     try {
71537       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71538     } catch (std::out_of_range& e) {
71539       {
71540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71541       };
71542     } catch (std::exception& e) {
71543       {
71544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71545       };
71546     } catch (...) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71549       };
71550     }
71551   }
71552   jresult = (void *)result;
71553   return jresult;
71554 }
71555
71556
71557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71558   void * jresult ;
71559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71560   Dali::Toolkit::TableView *arg2 = 0 ;
71561   Dali::Toolkit::TableView *result = 0 ;
71562
71563   arg1 = (Dali::Toolkit::TableView *)jarg1;
71564   arg2 = (Dali::Toolkit::TableView *)jarg2;
71565   if (!arg2) {
71566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71567     return 0;
71568   }
71569   {
71570     try {
71571       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71572     } catch (std::out_of_range& e) {
71573       {
71574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71575       };
71576     } catch (std::exception& e) {
71577       {
71578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71579       };
71580     } catch (...) {
71581       {
71582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71583       };
71584     }
71585   }
71586   jresult = (void *)result;
71587   return jresult;
71588 }
71589
71590
71591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71592   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71593
71594   arg1 = (Dali::Toolkit::TableView *)jarg1;
71595   {
71596     try {
71597       delete arg1;
71598     } catch (std::out_of_range& e) {
71599       {
71600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71601       };
71602     } catch (std::exception& e) {
71603       {
71604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71605       };
71606     } catch (...) {
71607       {
71608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71609       };
71610     }
71611   }
71612 }
71613
71614
71615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71616   void * jresult ;
71617   unsigned int arg1 ;
71618   unsigned int arg2 ;
71619   Dali::Toolkit::TableView result;
71620
71621   arg1 = (unsigned int)jarg1;
71622   arg2 = (unsigned int)jarg2;
71623   {
71624     try {
71625       result = Dali::Toolkit::TableView::New(arg1,arg2);
71626     } catch (std::out_of_range& e) {
71627       {
71628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71629       };
71630     } catch (std::exception& e) {
71631       {
71632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71633       };
71634     } catch (...) {
71635       {
71636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71637       };
71638     }
71639   }
71640   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71641   return jresult;
71642 }
71643
71644
71645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71646   void * jresult ;
71647   Dali::BaseHandle arg1 ;
71648   Dali::BaseHandle *argp1 ;
71649   Dali::Toolkit::TableView result;
71650
71651   argp1 = (Dali::BaseHandle *)jarg1;
71652   if (!argp1) {
71653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71654     return 0;
71655   }
71656   arg1 = *argp1;
71657   {
71658     try {
71659       result = Dali::Toolkit::TableView::DownCast(arg1);
71660     } catch (std::out_of_range& e) {
71661       {
71662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71663       };
71664     } catch (std::exception& e) {
71665       {
71666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71667       };
71668     } catch (...) {
71669       {
71670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71671       };
71672     }
71673   }
71674   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71675   return jresult;
71676 }
71677
71678
71679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71680   unsigned int jresult ;
71681   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71682   Dali::Actor arg2 ;
71683   Dali::Toolkit::TableView::CellPosition arg3 ;
71684   Dali::Actor *argp2 ;
71685   Dali::Toolkit::TableView::CellPosition *argp3 ;
71686   bool result;
71687
71688   arg1 = (Dali::Toolkit::TableView *)jarg1;
71689   argp2 = (Dali::Actor *)jarg2;
71690   if (!argp2) {
71691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71692     return 0;
71693   }
71694   arg2 = *argp2;
71695   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71696   if (!argp3) {
71697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71698     return 0;
71699   }
71700   arg3 = *argp3;
71701   {
71702     try {
71703       result = (bool)(arg1)->AddChild(arg2,arg3);
71704     } catch (std::out_of_range& e) {
71705       {
71706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (std::exception& e) {
71709       {
71710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71715       };
71716     }
71717   }
71718   jresult = result;
71719   return jresult;
71720 }
71721
71722
71723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71724   void * jresult ;
71725   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71726   Dali::Toolkit::TableView::CellPosition arg2 ;
71727   Dali::Toolkit::TableView::CellPosition *argp2 ;
71728   Dali::Actor result;
71729
71730   arg1 = (Dali::Toolkit::TableView *)jarg1;
71731   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71732   if (!argp2) {
71733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71734     return 0;
71735   }
71736   arg2 = *argp2;
71737   {
71738     try {
71739       result = (arg1)->GetChildAt(arg2);
71740     } catch (std::out_of_range& e) {
71741       {
71742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71743       };
71744     } catch (std::exception& e) {
71745       {
71746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71747       };
71748     } catch (...) {
71749       {
71750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71751       };
71752     }
71753   }
71754   jresult = new Dali::Actor((const Dali::Actor &)result);
71755   return jresult;
71756 }
71757
71758
71759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71760   void * jresult ;
71761   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71762   Dali::Toolkit::TableView::CellPosition arg2 ;
71763   Dali::Toolkit::TableView::CellPosition *argp2 ;
71764   Dali::Actor result;
71765
71766   arg1 = (Dali::Toolkit::TableView *)jarg1;
71767   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71768   if (!argp2) {
71769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71770     return 0;
71771   }
71772   arg2 = *argp2;
71773   {
71774     try {
71775       result = (arg1)->RemoveChildAt(arg2);
71776     } catch (std::out_of_range& e) {
71777       {
71778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71779       };
71780     } catch (std::exception& e) {
71781       {
71782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71783       };
71784     } catch (...) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71787       };
71788     }
71789   }
71790   jresult = new Dali::Actor((const Dali::Actor &)result);
71791   return jresult;
71792 }
71793
71794
71795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71796   unsigned int jresult ;
71797   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71798   Dali::Actor arg2 ;
71799   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71800   Dali::Actor *argp2 ;
71801   bool result;
71802
71803   arg1 = (Dali::Toolkit::TableView *)jarg1;
71804   argp2 = (Dali::Actor *)jarg2;
71805   if (!argp2) {
71806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71807     return 0;
71808   }
71809   arg2 = *argp2;
71810   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71811   if (!arg3) {
71812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71813     return 0;
71814   }
71815   {
71816     try {
71817       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71818     } catch (std::out_of_range& e) {
71819       {
71820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71821       };
71822     } catch (std::exception& e) {
71823       {
71824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71829       };
71830     }
71831   }
71832   jresult = result;
71833   return jresult;
71834 }
71835
71836
71837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71838   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71839   unsigned int arg2 ;
71840
71841   arg1 = (Dali::Toolkit::TableView *)jarg1;
71842   arg2 = (unsigned int)jarg2;
71843   {
71844     try {
71845       (arg1)->InsertRow(arg2);
71846     } catch (std::out_of_range& e) {
71847       {
71848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71849       };
71850     } catch (std::exception& e) {
71851       {
71852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71853       };
71854     } catch (...) {
71855       {
71856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71857       };
71858     }
71859   }
71860 }
71861
71862
71863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71864   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71865   unsigned int arg2 ;
71866
71867   arg1 = (Dali::Toolkit::TableView *)jarg1;
71868   arg2 = (unsigned int)jarg2;
71869   {
71870     try {
71871       (arg1)->DeleteRow(arg2);
71872     } catch (std::out_of_range& e) {
71873       {
71874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71875       };
71876     } catch (std::exception& e) {
71877       {
71878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71879       };
71880     } catch (...) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71883       };
71884     }
71885   }
71886 }
71887
71888
71889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71890   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71891   unsigned int arg2 ;
71892   std::vector< Dali::Actor > *arg3 = 0 ;
71893
71894   arg1 = (Dali::Toolkit::TableView *)jarg1;
71895   arg2 = (unsigned int)jarg2;
71896   arg3 = (std::vector< Dali::Actor > *)jarg3;
71897   if (!arg3) {
71898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71899     return ;
71900   }
71901   {
71902     try {
71903       (arg1)->DeleteRow(arg2,*arg3);
71904     } catch (std::out_of_range& e) {
71905       {
71906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71907       };
71908     } catch (std::exception& e) {
71909       {
71910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71911       };
71912     } catch (...) {
71913       {
71914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71915       };
71916     }
71917   }
71918 }
71919
71920
71921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71922   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71923   unsigned int arg2 ;
71924
71925   arg1 = (Dali::Toolkit::TableView *)jarg1;
71926   arg2 = (unsigned int)jarg2;
71927   {
71928     try {
71929       (arg1)->InsertColumn(arg2);
71930     } catch (std::out_of_range& e) {
71931       {
71932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (std::exception& e) {
71935       {
71936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71941       };
71942     }
71943   }
71944 }
71945
71946
71947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71948   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71949   unsigned int arg2 ;
71950
71951   arg1 = (Dali::Toolkit::TableView *)jarg1;
71952   arg2 = (unsigned int)jarg2;
71953   {
71954     try {
71955       (arg1)->DeleteColumn(arg2);
71956     } catch (std::out_of_range& e) {
71957       {
71958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71959       };
71960     } catch (std::exception& e) {
71961       {
71962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71963       };
71964     } catch (...) {
71965       {
71966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71967       };
71968     }
71969   }
71970 }
71971
71972
71973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71974   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71975   unsigned int arg2 ;
71976   std::vector< Dali::Actor > *arg3 = 0 ;
71977
71978   arg1 = (Dali::Toolkit::TableView *)jarg1;
71979   arg2 = (unsigned int)jarg2;
71980   arg3 = (std::vector< Dali::Actor > *)jarg3;
71981   if (!arg3) {
71982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71983     return ;
71984   }
71985   {
71986     try {
71987       (arg1)->DeleteColumn(arg2,*arg3);
71988     } catch (std::out_of_range& e) {
71989       {
71990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71991       };
71992     } catch (std::exception& e) {
71993       {
71994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71995       };
71996     } catch (...) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71999       };
72000     }
72001   }
72002 }
72003
72004
72005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
72006   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72007   unsigned int arg2 ;
72008   unsigned int arg3 ;
72009
72010   arg1 = (Dali::Toolkit::TableView *)jarg1;
72011   arg2 = (unsigned int)jarg2;
72012   arg3 = (unsigned int)jarg3;
72013   {
72014     try {
72015       (arg1)->Resize(arg2,arg3);
72016     } catch (std::out_of_range& e) {
72017       {
72018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72019       };
72020     } catch (std::exception& e) {
72021       {
72022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72023       };
72024     } catch (...) {
72025       {
72026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72027       };
72028     }
72029   }
72030 }
72031
72032
72033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72034   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72035   unsigned int arg2 ;
72036   unsigned int arg3 ;
72037   std::vector< Dali::Actor > *arg4 = 0 ;
72038
72039   arg1 = (Dali::Toolkit::TableView *)jarg1;
72040   arg2 = (unsigned int)jarg2;
72041   arg3 = (unsigned int)jarg3;
72042   arg4 = (std::vector< Dali::Actor > *)jarg4;
72043   if (!arg4) {
72044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72045     return ;
72046   }
72047   {
72048     try {
72049       (arg1)->Resize(arg2,arg3,*arg4);
72050     } catch (std::out_of_range& e) {
72051       {
72052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72053       };
72054     } catch (std::exception& e) {
72055       {
72056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72057       };
72058     } catch (...) {
72059       {
72060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72061       };
72062     }
72063   }
72064 }
72065
72066
72067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72068   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72069   Dali::Size arg2 ;
72070   Dali::Size *argp2 ;
72071
72072   arg1 = (Dali::Toolkit::TableView *)jarg1;
72073   argp2 = (Dali::Size *)jarg2;
72074   if (!argp2) {
72075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72076     return ;
72077   }
72078   arg2 = *argp2;
72079   {
72080     try {
72081       (arg1)->SetCellPadding(arg2);
72082     } catch (std::out_of_range& e) {
72083       {
72084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72085       };
72086     } catch (std::exception& e) {
72087       {
72088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72089       };
72090     } catch (...) {
72091       {
72092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72093       };
72094     }
72095   }
72096 }
72097
72098
72099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72100   void * jresult ;
72101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72102   Dali::Size result;
72103
72104   arg1 = (Dali::Toolkit::TableView *)jarg1;
72105   {
72106     try {
72107       result = (arg1)->GetCellPadding();
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72115       };
72116     } catch (...) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72119       };
72120     }
72121   }
72122   jresult = new Dali::Size((const Dali::Size &)result);
72123   return jresult;
72124 }
72125
72126
72127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72129   unsigned int arg2 ;
72130
72131   arg1 = (Dali::Toolkit::TableView *)jarg1;
72132   arg2 = (unsigned int)jarg2;
72133   {
72134     try {
72135       (arg1)->SetFitHeight(arg2);
72136     } catch (std::out_of_range& e) {
72137       {
72138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72139       };
72140     } catch (std::exception& e) {
72141       {
72142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72143       };
72144     } catch (...) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72147       };
72148     }
72149   }
72150 }
72151
72152
72153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72154   unsigned int jresult ;
72155   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72156   unsigned int arg2 ;
72157   bool result;
72158
72159   arg1 = (Dali::Toolkit::TableView *)jarg1;
72160   arg2 = (unsigned int)jarg2;
72161   {
72162     try {
72163       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72164     } catch (std::out_of_range& e) {
72165       {
72166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72167       };
72168     } catch (std::exception& e) {
72169       {
72170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (...) {
72173       {
72174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72175       };
72176     }
72177   }
72178   jresult = result;
72179   return jresult;
72180 }
72181
72182
72183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72184   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72185   unsigned int arg2 ;
72186
72187   arg1 = (Dali::Toolkit::TableView *)jarg1;
72188   arg2 = (unsigned int)jarg2;
72189   {
72190     try {
72191       (arg1)->SetFitWidth(arg2);
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72203       };
72204     }
72205   }
72206 }
72207
72208
72209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72210   unsigned int jresult ;
72211   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72212   unsigned int arg2 ;
72213   bool result;
72214
72215   arg1 = (Dali::Toolkit::TableView *)jarg1;
72216   arg2 = (unsigned int)jarg2;
72217   {
72218     try {
72219       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72220     } catch (std::out_of_range& e) {
72221       {
72222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72223       };
72224     } catch (std::exception& e) {
72225       {
72226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72227       };
72228     } catch (...) {
72229       {
72230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72231       };
72232     }
72233   }
72234   jresult = result;
72235   return jresult;
72236 }
72237
72238
72239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72240   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72241   unsigned int arg2 ;
72242   float arg3 ;
72243
72244   arg1 = (Dali::Toolkit::TableView *)jarg1;
72245   arg2 = (unsigned int)jarg2;
72246   arg3 = (float)jarg3;
72247   {
72248     try {
72249       (arg1)->SetFixedHeight(arg2,arg3);
72250     } catch (std::out_of_range& e) {
72251       {
72252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72253       };
72254     } catch (std::exception& e) {
72255       {
72256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72257       };
72258     } catch (...) {
72259       {
72260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72261       };
72262     }
72263   }
72264 }
72265
72266
72267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72268   float jresult ;
72269   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72270   unsigned int arg2 ;
72271   float result;
72272
72273   arg1 = (Dali::Toolkit::TableView *)jarg1;
72274   arg2 = (unsigned int)jarg2;
72275   {
72276     try {
72277       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72278     } catch (std::out_of_range& e) {
72279       {
72280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72281       };
72282     } catch (std::exception& e) {
72283       {
72284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72285       };
72286     } catch (...) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72289       };
72290     }
72291   }
72292   jresult = result;
72293   return jresult;
72294 }
72295
72296
72297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72298   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72299   unsigned int arg2 ;
72300   float arg3 ;
72301
72302   arg1 = (Dali::Toolkit::TableView *)jarg1;
72303   arg2 = (unsigned int)jarg2;
72304   arg3 = (float)jarg3;
72305   {
72306     try {
72307       (arg1)->SetRelativeHeight(arg2,arg3);
72308     } catch (std::out_of_range& e) {
72309       {
72310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72311       };
72312     } catch (std::exception& e) {
72313       {
72314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72315       };
72316     } catch (...) {
72317       {
72318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72319       };
72320     }
72321   }
72322 }
72323
72324
72325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72326   float jresult ;
72327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72328   unsigned int arg2 ;
72329   float result;
72330
72331   arg1 = (Dali::Toolkit::TableView *)jarg1;
72332   arg2 = (unsigned int)jarg2;
72333   {
72334     try {
72335       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72336     } catch (std::out_of_range& e) {
72337       {
72338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72339       };
72340     } catch (std::exception& e) {
72341       {
72342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72343       };
72344     } catch (...) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72347       };
72348     }
72349   }
72350   jresult = result;
72351   return jresult;
72352 }
72353
72354
72355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72356   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72357   unsigned int arg2 ;
72358   float arg3 ;
72359
72360   arg1 = (Dali::Toolkit::TableView *)jarg1;
72361   arg2 = (unsigned int)jarg2;
72362   arg3 = (float)jarg3;
72363   {
72364     try {
72365       (arg1)->SetFixedWidth(arg2,arg3);
72366     } catch (std::out_of_range& e) {
72367       {
72368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72369       };
72370     } catch (std::exception& e) {
72371       {
72372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72373       };
72374     } catch (...) {
72375       {
72376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72377       };
72378     }
72379   }
72380 }
72381
72382
72383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72384   float jresult ;
72385   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72386   unsigned int arg2 ;
72387   float result;
72388
72389   arg1 = (Dali::Toolkit::TableView *)jarg1;
72390   arg2 = (unsigned int)jarg2;
72391   {
72392     try {
72393       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72394     } catch (std::out_of_range& e) {
72395       {
72396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (std::exception& e) {
72399       {
72400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72401       };
72402     } catch (...) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72405       };
72406     }
72407   }
72408   jresult = result;
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72414   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72415   unsigned int arg2 ;
72416   float arg3 ;
72417
72418   arg1 = (Dali::Toolkit::TableView *)jarg1;
72419   arg2 = (unsigned int)jarg2;
72420   arg3 = (float)jarg3;
72421   {
72422     try {
72423       (arg1)->SetRelativeWidth(arg2,arg3);
72424     } catch (std::out_of_range& e) {
72425       {
72426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72427       };
72428     } catch (std::exception& e) {
72429       {
72430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72431       };
72432     } catch (...) {
72433       {
72434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72435       };
72436     }
72437   }
72438 }
72439
72440
72441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72442   float jresult ;
72443   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72444   unsigned int arg2 ;
72445   float result;
72446
72447   arg1 = (Dali::Toolkit::TableView *)jarg1;
72448   arg2 = (unsigned int)jarg2;
72449   {
72450     try {
72451       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72452     } catch (std::out_of_range& e) {
72453       {
72454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72455       };
72456     } catch (std::exception& e) {
72457       {
72458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72459       };
72460     } catch (...) {
72461       {
72462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72463       };
72464     }
72465   }
72466   jresult = result;
72467   return jresult;
72468 }
72469
72470
72471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72472   unsigned int jresult ;
72473   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72474   unsigned int result;
72475
72476   arg1 = (Dali::Toolkit::TableView *)jarg1;
72477   {
72478     try {
72479       result = (unsigned int)(arg1)->GetRows();
72480     } catch (std::out_of_range& e) {
72481       {
72482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72483       };
72484     } catch (std::exception& e) {
72485       {
72486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72487       };
72488     } catch (...) {
72489       {
72490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72491       };
72492     }
72493   }
72494   jresult = result;
72495   return jresult;
72496 }
72497
72498
72499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72500   unsigned int jresult ;
72501   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72502   unsigned int result;
72503
72504   arg1 = (Dali::Toolkit::TableView *)jarg1;
72505   {
72506     try {
72507       result = (unsigned int)(arg1)->GetColumns();
72508     } catch (std::out_of_range& e) {
72509       {
72510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (std::exception& e) {
72513       {
72514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (...) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72519       };
72520     }
72521   }
72522   jresult = result;
72523   return jresult;
72524 }
72525
72526
72527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72529   Dali::Toolkit::TableView::CellPosition arg2 ;
72530   Dali::HorizontalAlignment::Type arg3 ;
72531   Dali::VerticalAlignment::Type arg4 ;
72532   Dali::Toolkit::TableView::CellPosition *argp2 ;
72533
72534   arg1 = (Dali::Toolkit::TableView *)jarg1;
72535   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72536   if (!argp2) {
72537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72538     return ;
72539   }
72540   arg2 = *argp2;
72541   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72542   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72543   {
72544     try {
72545       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72546     } catch (std::out_of_range& e) {
72547       {
72548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72549       };
72550     } catch (std::exception& e) {
72551       {
72552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72553       };
72554     } catch (...) {
72555       {
72556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72557       };
72558     }
72559   }
72560 }
72561
72562
72563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72564   unsigned int jresult ;
72565   unsigned int result;
72566
72567   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72568   jresult = result;
72569   return jresult;
72570 }
72571
72572
72573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72574   int jresult ;
72575   int result;
72576
72577   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72578   jresult = (int)result;
72579   return jresult;
72580 }
72581
72582
72583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72584   int jresult ;
72585   int result;
72586
72587   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72588   jresult = (int)result;
72589   return jresult;
72590 }
72591
72592
72593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72594   int jresult ;
72595   int result;
72596
72597   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72598   jresult = (int)result;
72599   return jresult;
72600 }
72601
72602
72603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72604   int jresult ;
72605   int result;
72606
72607   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72608   jresult = (int)result;
72609   return jresult;
72610 }
72611
72612
72613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72614   int jresult ;
72615   int result;
72616
72617   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72618   jresult = (int)result;
72619   return jresult;
72620 }
72621
72622
72623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72624   int jresult ;
72625   int result;
72626
72627   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72628   jresult = (int)result;
72629   return jresult;
72630 }
72631
72632
72633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72634   int jresult ;
72635   int result;
72636
72637   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72638   jresult = (int)result;
72639   return jresult;
72640 }
72641
72642
72643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72644   int jresult ;
72645   int result;
72646
72647   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72648   jresult = (int)result;
72649   return jresult;
72650 }
72651
72652
72653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72654   int jresult ;
72655   int result;
72656
72657   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72658   jresult = (int)result;
72659   return jresult;
72660 }
72661
72662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
72663   int jresult ;
72664   int result;
72665
72666   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
72667   jresult = (int)result;
72668   return jresult;
72669 }
72670
72671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72672   int jresult ;
72673   int result;
72674
72675   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72676   jresult = (int)result;
72677   return jresult;
72678 }
72679
72680
72681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72682   int jresult ;
72683   int result;
72684
72685   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72686   jresult = (int)result;
72687   return jresult;
72688 }
72689
72690
72691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72692   int jresult ;
72693   int result;
72694
72695   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72696   jresult = (int)result;
72697   return jresult;
72698 }
72699
72700
72701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72702   int jresult ;
72703   int result;
72704
72705   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72706   jresult = (int)result;
72707   return jresult;
72708 }
72709
72710
72711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72712   int jresult ;
72713   int result;
72714
72715   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72716   jresult = (int)result;
72717   return jresult;
72718 }
72719
72720
72721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72722   int jresult ;
72723   int result;
72724
72725   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72726   jresult = (int)result;
72727   return jresult;
72728 }
72729
72730
72731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72732   int jresult ;
72733   int result;
72734
72735   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72736   jresult = (int)result;
72737   return jresult;
72738 }
72739
72740
72741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72742   int jresult ;
72743   int result;
72744
72745   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72746   jresult = (int)result;
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72752   int jresult ;
72753   int result;
72754
72755   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72756   jresult = (int)result;
72757   return jresult;
72758 }
72759
72760
72761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72762   int jresult ;
72763   int result;
72764
72765   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72766   jresult = (int)result;
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72772   int jresult ;
72773   int result;
72774
72775   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72776   jresult = (int)result;
72777   return jresult;
72778 }
72779
72780
72781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72782   int jresult ;
72783   int result;
72784
72785   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72786   jresult = (int)result;
72787   return jresult;
72788 }
72789
72790
72791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72792   int jresult ;
72793   int result;
72794
72795   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72796   jresult = (int)result;
72797   return jresult;
72798 }
72799
72800
72801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72802   int jresult ;
72803   int result;
72804
72805   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72806   jresult = (int)result;
72807   return jresult;
72808 }
72809
72810
72811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72812   int jresult ;
72813   int result;
72814
72815   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72816   jresult = (int)result;
72817   return jresult;
72818 }
72819
72820
72821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72822   void * jresult ;
72823   Dali::Toolkit::TextLabel::Property *result = 0 ;
72824
72825   {
72826     try {
72827       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72828     } catch (std::out_of_range& e) {
72829       {
72830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72831       };
72832     } catch (std::exception& e) {
72833       {
72834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72835       };
72836     } catch (...) {
72837       {
72838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72839       };
72840     }
72841   }
72842   jresult = (void *)result;
72843   return jresult;
72844 }
72845
72846
72847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72848   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72849
72850   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72851   {
72852     try {
72853       delete arg1;
72854     } catch (std::out_of_range& e) {
72855       {
72856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72857       };
72858     } catch (std::exception& e) {
72859       {
72860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72861       };
72862     } catch (...) {
72863       {
72864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72865       };
72866     }
72867   }
72868 }
72869
72870
72871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72872   void * jresult ;
72873   Dali::Toolkit::TextLabel result;
72874
72875   {
72876     try {
72877       result = Dali::Toolkit::TextLabel::New();
72878     } catch (std::out_of_range& e) {
72879       {
72880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72881       };
72882     } catch (std::exception& e) {
72883       {
72884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72885       };
72886     } catch (...) {
72887       {
72888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72889       };
72890     }
72891   }
72892   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72893   return jresult;
72894 }
72895
72896
72897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72898   void * jresult ;
72899   std::string *arg1 = 0 ;
72900   Dali::Toolkit::TextLabel result;
72901
72902   if (!jarg1) {
72903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72904     return 0;
72905   }
72906   std::string arg1_str(jarg1);
72907   arg1 = &arg1_str;
72908   {
72909     try {
72910       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72911     } catch (std::out_of_range& e) {
72912       {
72913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72914       };
72915     } catch (std::exception& e) {
72916       {
72917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72918       };
72919     } catch (...) {
72920       {
72921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72922       };
72923     }
72924   }
72925   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72926
72927   //argout typemap for const std::string&
72928
72929   return jresult;
72930 }
72931
72932
72933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72934   void * jresult ;
72935   Dali::Toolkit::TextLabel *result = 0 ;
72936
72937   {
72938     try {
72939       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72940     } catch (std::out_of_range& e) {
72941       {
72942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72943       };
72944     } catch (std::exception& e) {
72945       {
72946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72947       };
72948     } catch (...) {
72949       {
72950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72951       };
72952     }
72953   }
72954   jresult = (void *)result;
72955   return jresult;
72956 }
72957
72958
72959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72960   void * jresult ;
72961   Dali::Toolkit::TextLabel *arg1 = 0 ;
72962   Dali::Toolkit::TextLabel *result = 0 ;
72963
72964   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72965   if (!arg1) {
72966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72967     return 0;
72968   }
72969   {
72970     try {
72971       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72972     } catch (std::out_of_range& e) {
72973       {
72974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72975       };
72976     } catch (std::exception& e) {
72977       {
72978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72979       };
72980     } catch (...) {
72981       {
72982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72983       };
72984     }
72985   }
72986   jresult = (void *)result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72992   void * jresult ;
72993   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72994   Dali::Toolkit::TextLabel *arg2 = 0 ;
72995   Dali::Toolkit::TextLabel *result = 0 ;
72996
72997   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72998   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72999   if (!arg2) {
73000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
73001     return 0;
73002   }
73003   {
73004     try {
73005       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
73006     } catch (std::out_of_range& e) {
73007       {
73008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73009       };
73010     } catch (std::exception& e) {
73011       {
73012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73013       };
73014     } catch (...) {
73015       {
73016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73017       };
73018     }
73019   }
73020   jresult = (void *)result;
73021   return jresult;
73022 }
73023
73024
73025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
73026   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
73027
73028   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73029   {
73030     try {
73031       delete arg1;
73032     } catch (std::out_of_range& e) {
73033       {
73034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73035       };
73036     } catch (std::exception& e) {
73037       {
73038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73039       };
73040     } catch (...) {
73041       {
73042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73043       };
73044     }
73045   }
73046 }
73047
73048
73049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73050   void * jresult ;
73051   Dali::BaseHandle arg1 ;
73052   Dali::BaseHandle *argp1 ;
73053   Dali::Toolkit::TextLabel result;
73054
73055   argp1 = (Dali::BaseHandle *)jarg1;
73056   if (!argp1) {
73057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73058     return 0;
73059   }
73060   arg1 = *argp1;
73061   {
73062     try {
73063       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73064     } catch (std::out_of_range& e) {
73065       {
73066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73067       };
73068     } catch (std::exception& e) {
73069       {
73070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73071       };
73072     } catch (...) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73075       };
73076     }
73077   }
73078   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73079   return jresult;
73080 }
73081
73082
73083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73084   void * jresult ;
73085   Dali::Toolkit::AccessibilityManager *result = 0 ;
73086
73087   {
73088     try {
73089       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73090     } catch (std::out_of_range& e) {
73091       {
73092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73093       };
73094     } catch (std::exception& e) {
73095       {
73096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73097       };
73098     } catch (...) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73101       };
73102     }
73103   }
73104   jresult = (void *)result;
73105   return jresult;
73106 }
73107
73108
73109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73111
73112   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73113   {
73114     try {
73115       delete arg1;
73116     } catch (std::out_of_range& e) {
73117       {
73118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73119       };
73120     } catch (std::exception& e) {
73121       {
73122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73123       };
73124     } catch (...) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73127       };
73128     }
73129   }
73130 }
73131
73132
73133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73134   void * jresult ;
73135   Dali::Toolkit::AccessibilityManager result;
73136
73137   {
73138     try {
73139       result = Dali::Toolkit::AccessibilityManager::Get();
73140     } catch (std::out_of_range& e) {
73141       {
73142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73143       };
73144     } catch (std::exception& e) {
73145       {
73146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73147       };
73148     } catch (...) {
73149       {
73150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73151       };
73152     }
73153   }
73154   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73155   return jresult;
73156 }
73157
73158
73159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73161   Dali::Actor arg2 ;
73162   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73163   std::string *arg4 = 0 ;
73164   Dali::Actor *argp2 ;
73165
73166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73167   argp2 = (Dali::Actor *)jarg2;
73168   if (!argp2) {
73169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73170     return ;
73171   }
73172   arg2 = *argp2;
73173   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73174   if (!jarg4) {
73175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73176     return ;
73177   }
73178   std::string arg4_str(jarg4);
73179   arg4 = &arg4_str;
73180   {
73181     try {
73182       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73183     } catch (std::out_of_range& e) {
73184       {
73185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73186       };
73187     } catch (std::exception& e) {
73188       {
73189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73190       };
73191     } catch (...) {
73192       {
73193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73194       };
73195     }
73196   }
73197
73198   //argout typemap for const std::string&
73199
73200 }
73201
73202
73203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73204   char * jresult ;
73205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73206   Dali::Actor arg2 ;
73207   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73208   Dali::Actor *argp2 ;
73209   std::string result;
73210
73211   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73212   argp2 = (Dali::Actor *)jarg2;
73213   if (!argp2) {
73214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73215     return 0;
73216   }
73217   arg2 = *argp2;
73218   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73219   {
73220     try {
73221       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73222     } catch (std::out_of_range& e) {
73223       {
73224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73225       };
73226     } catch (std::exception& e) {
73227       {
73228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73229       };
73230     } catch (...) {
73231       {
73232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73233       };
73234     }
73235   }
73236   jresult = SWIG_csharp_string_callback((&result)->c_str());
73237   return jresult;
73238 }
73239
73240
73241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73243   Dali::Actor arg2 ;
73244   unsigned int arg3 ;
73245   Dali::Actor *argp2 ;
73246
73247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73248   argp2 = (Dali::Actor *)jarg2;
73249   if (!argp2) {
73250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73251     return ;
73252   }
73253   arg2 = *argp2;
73254   arg3 = (unsigned int)jarg3;
73255   {
73256     try {
73257       (arg1)->SetFocusOrder(arg2,arg3);
73258     } catch (std::out_of_range& e) {
73259       {
73260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73261       };
73262     } catch (std::exception& e) {
73263       {
73264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73265       };
73266     } catch (...) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73269       };
73270     }
73271   }
73272 }
73273
73274
73275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73276   unsigned int jresult ;
73277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73278   Dali::Actor arg2 ;
73279   Dali::Actor *argp2 ;
73280   unsigned int result;
73281
73282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73283   argp2 = (Dali::Actor *)jarg2;
73284   if (!argp2) {
73285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73286     return 0;
73287   }
73288   arg2 = *argp2;
73289   {
73290     try {
73291       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73292     } catch (std::out_of_range& e) {
73293       {
73294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73295       };
73296     } catch (std::exception& e) {
73297       {
73298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73299       };
73300     } catch (...) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73303       };
73304     }
73305   }
73306   jresult = result;
73307   return jresult;
73308 }
73309
73310
73311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73312   unsigned int jresult ;
73313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73314   unsigned int result;
73315
73316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73317   {
73318     try {
73319       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73320     } catch (std::out_of_range& e) {
73321       {
73322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (std::exception& e) {
73325       {
73326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73327       };
73328     } catch (...) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73331       };
73332     }
73333   }
73334   jresult = result;
73335   return jresult;
73336 }
73337
73338
73339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73340   void * jresult ;
73341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73342   unsigned int arg2 ;
73343   Dali::Actor result;
73344
73345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73346   arg2 = (unsigned int)jarg2;
73347   {
73348     try {
73349       result = (arg1)->GetActorByFocusOrder(arg2);
73350     } catch (std::out_of_range& e) {
73351       {
73352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73353       };
73354     } catch (std::exception& e) {
73355       {
73356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (...) {
73359       {
73360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73361       };
73362     }
73363   }
73364   jresult = new Dali::Actor((const Dali::Actor &)result);
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73370   unsigned int jresult ;
73371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73372   Dali::Actor arg2 ;
73373   Dali::Actor *argp2 ;
73374   bool result;
73375
73376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73377   argp2 = (Dali::Actor *)jarg2;
73378   if (!argp2) {
73379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73380     return 0;
73381   }
73382   arg2 = *argp2;
73383   {
73384     try {
73385       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73386     } catch (std::out_of_range& e) {
73387       {
73388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (std::exception& e) {
73391       {
73392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73393       };
73394     } catch (...) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73397       };
73398     }
73399   }
73400   jresult = result;
73401   return jresult;
73402 }
73403
73404
73405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73406   void * jresult ;
73407   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73408   Dali::Actor result;
73409
73410   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73411   {
73412     try {
73413       result = (arg1)->GetCurrentFocusActor();
73414     } catch (std::out_of_range& e) {
73415       {
73416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73417       };
73418     } catch (std::exception& e) {
73419       {
73420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73421       };
73422     } catch (...) {
73423       {
73424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73425       };
73426     }
73427   }
73428   jresult = new Dali::Actor((const Dali::Actor &)result);
73429   return jresult;
73430 }
73431
73432
73433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73434   void * jresult ;
73435   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73436   Dali::Actor result;
73437
73438   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73439   {
73440     try {
73441       result = (arg1)->GetCurrentFocusGroup();
73442     } catch (std::out_of_range& e) {
73443       {
73444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73445       };
73446     } catch (std::exception& e) {
73447       {
73448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73449       };
73450     } catch (...) {
73451       {
73452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73453       };
73454     }
73455   }
73456   jresult = new Dali::Actor((const Dali::Actor &)result);
73457   return jresult;
73458 }
73459
73460
73461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73462   unsigned int jresult ;
73463   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73464   unsigned int result;
73465
73466   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73467   {
73468     try {
73469       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73470     } catch (std::out_of_range& e) {
73471       {
73472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73473       };
73474     } catch (std::exception& e) {
73475       {
73476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73477       };
73478     } catch (...) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73481       };
73482     }
73483   }
73484   jresult = result;
73485   return jresult;
73486 }
73487
73488
73489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73490   unsigned int jresult ;
73491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73492   bool result;
73493
73494   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73495   {
73496     try {
73497       result = (bool)(arg1)->MoveFocusForward();
73498     } catch (std::out_of_range& e) {
73499       {
73500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73501       };
73502     } catch (std::exception& e) {
73503       {
73504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73505       };
73506     } catch (...) {
73507       {
73508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73509       };
73510     }
73511   }
73512   jresult = result;
73513   return jresult;
73514 }
73515
73516
73517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73518   unsigned int jresult ;
73519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73520   bool result;
73521
73522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73523   {
73524     try {
73525       result = (bool)(arg1)->MoveFocusBackward();
73526     } catch (std::out_of_range& e) {
73527       {
73528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73529       };
73530     } catch (std::exception& e) {
73531       {
73532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73533       };
73534     } catch (...) {
73535       {
73536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73537       };
73538     }
73539   }
73540   jresult = result;
73541   return jresult;
73542 }
73543
73544
73545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73547
73548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73549   {
73550     try {
73551       (arg1)->ClearFocus();
73552     } catch (std::out_of_range& e) {
73553       {
73554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73555       };
73556     } catch (std::exception& e) {
73557       {
73558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73559       };
73560     } catch (...) {
73561       {
73562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73563       };
73564     }
73565   }
73566 }
73567
73568
73569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73571
73572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73573   {
73574     try {
73575       (arg1)->Reset();
73576     } catch (std::out_of_range& e) {
73577       {
73578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73579       };
73580     } catch (std::exception& e) {
73581       {
73582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73583       };
73584     } catch (...) {
73585       {
73586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73587       };
73588     }
73589   }
73590 }
73591
73592
73593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73595   Dali::Actor arg2 ;
73596   bool arg3 ;
73597   Dali::Actor *argp2 ;
73598
73599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73600   argp2 = (Dali::Actor *)jarg2;
73601   if (!argp2) {
73602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73603     return ;
73604   }
73605   arg2 = *argp2;
73606   arg3 = jarg3 ? true : false;
73607   {
73608     try {
73609       (arg1)->SetFocusGroup(arg2,arg3);
73610     } catch (std::out_of_range& e) {
73611       {
73612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73613       };
73614     } catch (std::exception& e) {
73615       {
73616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73617       };
73618     } catch (...) {
73619       {
73620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73621       };
73622     }
73623   }
73624 }
73625
73626
73627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73628   unsigned int jresult ;
73629   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73630   Dali::Actor arg2 ;
73631   Dali::Actor *argp2 ;
73632   bool result;
73633
73634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73635   argp2 = (Dali::Actor *)jarg2;
73636   if (!argp2) {
73637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73638     return 0;
73639   }
73640   arg2 = *argp2;
73641   {
73642     try {
73643       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73644     } catch (std::out_of_range& e) {
73645       {
73646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73647       };
73648     } catch (std::exception& e) {
73649       {
73650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73651       };
73652     } catch (...) {
73653       {
73654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73655       };
73656     }
73657   }
73658   jresult = result;
73659   return jresult;
73660 }
73661
73662
73663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73665   bool arg2 ;
73666
73667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73668   arg2 = jarg2 ? true : false;
73669   {
73670     try {
73671       (arg1)->SetGroupMode(arg2);
73672     } catch (std::out_of_range& e) {
73673       {
73674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73675       };
73676     } catch (std::exception& e) {
73677       {
73678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73679       };
73680     } catch (...) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73683       };
73684     }
73685   }
73686 }
73687
73688
73689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73690   unsigned int jresult ;
73691   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73692   bool result;
73693
73694   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73695   {
73696     try {
73697       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73698     } catch (std::out_of_range& e) {
73699       {
73700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73701       };
73702     } catch (std::exception& e) {
73703       {
73704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73705       };
73706     } catch (...) {
73707       {
73708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73709       };
73710     }
73711   }
73712   jresult = result;
73713   return jresult;
73714 }
73715
73716
73717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73719   bool arg2 ;
73720
73721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73722   arg2 = jarg2 ? true : false;
73723   {
73724     try {
73725       (arg1)->SetWrapMode(arg2);
73726     } catch (std::out_of_range& e) {
73727       {
73728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73729       };
73730     } catch (std::exception& e) {
73731       {
73732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73737       };
73738     }
73739   }
73740 }
73741
73742
73743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73744   unsigned int jresult ;
73745   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73746   bool result;
73747
73748   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73749   {
73750     try {
73751       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73752     } catch (std::out_of_range& e) {
73753       {
73754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73755       };
73756     } catch (std::exception& e) {
73757       {
73758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (...) {
73761       {
73762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73763       };
73764     }
73765   }
73766   jresult = result;
73767   return jresult;
73768 }
73769
73770
73771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73772   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73773   Dali::Actor arg2 ;
73774   Dali::Actor *argp2 ;
73775
73776   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73777   argp2 = (Dali::Actor *)jarg2;
73778   if (!argp2) {
73779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73780     return ;
73781   }
73782   arg2 = *argp2;
73783   {
73784     try {
73785       (arg1)->SetFocusIndicatorActor(arg2);
73786     } catch (std::out_of_range& e) {
73787       {
73788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73789       };
73790     } catch (std::exception& e) {
73791       {
73792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73793       };
73794     } catch (...) {
73795       {
73796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73797       };
73798     }
73799   }
73800 }
73801
73802
73803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73804   void * jresult ;
73805   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73806   Dali::Actor result;
73807
73808   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73809   {
73810     try {
73811       result = (arg1)->GetFocusIndicatorActor();
73812     } catch (std::out_of_range& e) {
73813       {
73814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73815       };
73816     } catch (std::exception& e) {
73817       {
73818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73819       };
73820     } catch (...) {
73821       {
73822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73823       };
73824     }
73825   }
73826   jresult = new Dali::Actor((const Dali::Actor &)result);
73827   return jresult;
73828 }
73829
73830
73831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73832   void * jresult ;
73833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73834   Dali::Actor arg2 ;
73835   Dali::Actor *argp2 ;
73836   Dali::Actor result;
73837
73838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73839   argp2 = (Dali::Actor *)jarg2;
73840   if (!argp2) {
73841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73842     return 0;
73843   }
73844   arg2 = *argp2;
73845   {
73846     try {
73847       result = (arg1)->GetFocusGroup(arg2);
73848     } catch (std::out_of_range& e) {
73849       {
73850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73851       };
73852     } catch (std::exception& e) {
73853       {
73854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (...) {
73857       {
73858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73859       };
73860     }
73861   }
73862   jresult = new Dali::Actor((const Dali::Actor &)result);
73863   return jresult;
73864 }
73865
73866
73867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73868   void * jresult ;
73869   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73870   Dali::Vector2 result;
73871
73872   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73873   {
73874     try {
73875       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73876     } catch (std::out_of_range& e) {
73877       {
73878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73879       };
73880     } catch (std::exception& e) {
73881       {
73882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73883       };
73884     } catch (...) {
73885       {
73886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73887       };
73888     }
73889   }
73890   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73891   return jresult;
73892 }
73893
73894
73895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73896   void * jresult ;
73897   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73898   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73899
73900   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73901   {
73902     try {
73903       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73904     } catch (std::out_of_range& e) {
73905       {
73906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73907       };
73908     } catch (std::exception& e) {
73909       {
73910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73911       };
73912     } catch (...) {
73913       {
73914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73915       };
73916     }
73917   }
73918   jresult = (void *)result;
73919   return jresult;
73920 }
73921
73922
73923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73924   void * jresult ;
73925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73926   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73927
73928   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73929   {
73930     try {
73931       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73932     } catch (std::out_of_range& e) {
73933       {
73934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73935       };
73936     } catch (std::exception& e) {
73937       {
73938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73939       };
73940     } catch (...) {
73941       {
73942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73943       };
73944     }
73945   }
73946   jresult = (void *)result;
73947   return jresult;
73948 }
73949
73950
73951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73952   void * jresult ;
73953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73954   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73955
73956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73957   {
73958     try {
73959       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73960     } catch (std::out_of_range& e) {
73961       {
73962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73963       };
73964     } catch (std::exception& e) {
73965       {
73966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73967       };
73968     } catch (...) {
73969       {
73970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73971       };
73972     }
73973   }
73974   jresult = (void *)result;
73975   return jresult;
73976 }
73977
73978
73979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73980   void * jresult ;
73981   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73982   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73983
73984   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73985   {
73986     try {
73987       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73988     } catch (std::out_of_range& e) {
73989       {
73990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (std::exception& e) {
73993       {
73994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002   jresult = (void *)result;
74003   return jresult;
74004 }
74005
74006
74007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
74008   void * jresult ;
74009   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74010   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74011
74012   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74013   {
74014     try {
74015       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
74016     } catch (std::out_of_range& e) {
74017       {
74018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (std::exception& e) {
74021       {
74022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74027       };
74028     }
74029   }
74030   jresult = (void *)result;
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
74036   void * jresult ;
74037   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74038   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74039
74040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74041   {
74042     try {
74043       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74044     } catch (std::out_of_range& e) {
74045       {
74046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (std::exception& e) {
74049       {
74050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (...) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74055       };
74056     }
74057   }
74058   jresult = (void *)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74064   void * jresult ;
74065   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74066   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74067
74068   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74069   {
74070     try {
74071       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74072     } catch (std::out_of_range& e) {
74073       {
74074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74075       };
74076     } catch (std::exception& e) {
74077       {
74078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74079       };
74080     } catch (...) {
74081       {
74082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74083       };
74084     }
74085   }
74086   jresult = (void *)result;
74087   return jresult;
74088 }
74089
74090
74091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74092   void * jresult ;
74093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74094   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74095
74096   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74097   {
74098     try {
74099       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74100     } catch (std::out_of_range& e) {
74101       {
74102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74103       };
74104     } catch (std::exception& e) {
74105       {
74106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74107       };
74108     } catch (...) {
74109       {
74110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74111       };
74112     }
74113   }
74114   jresult = (void *)result;
74115   return jresult;
74116 }
74117
74118
74119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74120   void * jresult ;
74121   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74122   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74123
74124   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74125   {
74126     try {
74127       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74128     } catch (std::out_of_range& e) {
74129       {
74130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74131       };
74132     } catch (std::exception& e) {
74133       {
74134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74135       };
74136     } catch (...) {
74137       {
74138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74139       };
74140     }
74141   }
74142   jresult = (void *)result;
74143   return jresult;
74144 }
74145
74146
74147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74148   void * jresult ;
74149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74150   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74151
74152   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74153   {
74154     try {
74155       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74156     } catch (std::out_of_range& e) {
74157       {
74158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (std::exception& e) {
74161       {
74162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (...) {
74165       {
74166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74167       };
74168     }
74169   }
74170   jresult = (void *)result;
74171   return jresult;
74172 }
74173
74174
74175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74176   void * jresult ;
74177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74178   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74179
74180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74181   {
74182     try {
74183       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74184     } catch (std::out_of_range& e) {
74185       {
74186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74187       };
74188     } catch (std::exception& e) {
74189       {
74190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74191       };
74192     } catch (...) {
74193       {
74194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74195       };
74196     }
74197   }
74198   jresult = (void *)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74204   void * jresult ;
74205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74206   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74207
74208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74209   {
74210     try {
74211       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74212     } catch (std::out_of_range& e) {
74213       {
74214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (std::exception& e) {
74217       {
74218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74219       };
74220     } catch (...) {
74221       {
74222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74223       };
74224     }
74225   }
74226   jresult = (void *)result;
74227   return jresult;
74228 }
74229
74230
74231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74232   void * jresult ;
74233   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74234   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74235
74236   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74237   {
74238     try {
74239       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74240     } catch (std::out_of_range& e) {
74241       {
74242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74243       };
74244     } catch (std::exception& e) {
74245       {
74246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74247       };
74248     } catch (...) {
74249       {
74250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74251       };
74252     }
74253   }
74254   jresult = (void *)result;
74255   return jresult;
74256 }
74257
74258
74259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74260   void * jresult ;
74261   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74262   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74263
74264   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74265   {
74266     try {
74267       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74268     } catch (std::out_of_range& e) {
74269       {
74270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74271       };
74272     } catch (std::exception& e) {
74273       {
74274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (...) {
74277       {
74278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74279       };
74280     }
74281   }
74282   jresult = (void *)result;
74283   return jresult;
74284 }
74285
74286
74287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74288   void * jresult ;
74289   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74290   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74291
74292   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74293   {
74294     try {
74295       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74296     } catch (std::out_of_range& e) {
74297       {
74298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74299       };
74300     } catch (std::exception& e) {
74301       {
74302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74303       };
74304     } catch (...) {
74305       {
74306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74307       };
74308     }
74309   }
74310   jresult = (void *)result;
74311   return jresult;
74312 }
74313
74314
74315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74316   void * jresult ;
74317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74318   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74319
74320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74321   {
74322     try {
74323       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74324     } catch (std::out_of_range& e) {
74325       {
74326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74327       };
74328     } catch (std::exception& e) {
74329       {
74330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74331       };
74332     } catch (...) {
74333       {
74334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74335       };
74336     }
74337   }
74338   jresult = (void *)result;
74339   return jresult;
74340 }
74341
74342
74343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74344   void * jresult ;
74345   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74346   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74347
74348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74349   {
74350     try {
74351       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74352     } catch (std::out_of_range& e) {
74353       {
74354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74355       };
74356     } catch (std::exception& e) {
74357       {
74358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74359       };
74360     } catch (...) {
74361       {
74362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74363       };
74364     }
74365   }
74366   jresult = (void *)result;
74367   return jresult;
74368 }
74369
74370
74371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74372   void * jresult ;
74373   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74374   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74375
74376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74377   {
74378     try {
74379       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74380     } catch (std::out_of_range& e) {
74381       {
74382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74383       };
74384     } catch (std::exception& e) {
74385       {
74386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74387       };
74388     } catch (...) {
74389       {
74390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74391       };
74392     }
74393   }
74394   jresult = (void *)result;
74395   return jresult;
74396 }
74397
74398
74399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74400   void * jresult ;
74401   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74402   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74403
74404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74405   {
74406     try {
74407       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74408     } catch (std::out_of_range& e) {
74409       {
74410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74411       };
74412     } catch (std::exception& e) {
74413       {
74414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74415       };
74416     } catch (...) {
74417       {
74418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74419       };
74420     }
74421   }
74422   jresult = (void *)result;
74423   return jresult;
74424 }
74425
74426
74427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74428   void * jresult ;
74429   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74430   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74431
74432   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74433   {
74434     try {
74435       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74436     } catch (std::out_of_range& e) {
74437       {
74438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74439       };
74440     } catch (std::exception& e) {
74441       {
74442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74443       };
74444     } catch (...) {
74445       {
74446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74447       };
74448     }
74449   }
74450   jresult = (void *)result;
74451   return jresult;
74452 }
74453
74454
74455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74456   void * jresult ;
74457   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74458   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74459
74460   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74461   {
74462     try {
74463       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74464     } catch (std::out_of_range& e) {
74465       {
74466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74467       };
74468     } catch (std::exception& e) {
74469       {
74470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74471       };
74472     } catch (...) {
74473       {
74474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74475       };
74476     }
74477   }
74478   jresult = (void *)result;
74479   return jresult;
74480 }
74481
74482
74483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74484   void * jresult ;
74485   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74486   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74487
74488   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74489   {
74490     try {
74491       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74492     } catch (std::out_of_range& e) {
74493       {
74494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74495       };
74496     } catch (std::exception& e) {
74497       {
74498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74499       };
74500     } catch (...) {
74501       {
74502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74503       };
74504     }
74505   }
74506   jresult = (void *)result;
74507   return jresult;
74508 }
74509
74510
74511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74512   void * jresult ;
74513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74514   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74515
74516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74517   {
74518     try {
74519       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74520     } catch (std::out_of_range& e) {
74521       {
74522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (std::exception& e) {
74525       {
74526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (...) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74531       };
74532     }
74533   }
74534   jresult = (void *)result;
74535   return jresult;
74536 }
74537
74538
74539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74540   void * jresult ;
74541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74542   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74543
74544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74545   {
74546     try {
74547       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74548     } catch (std::out_of_range& e) {
74549       {
74550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74551       };
74552     } catch (std::exception& e) {
74553       {
74554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74555       };
74556     } catch (...) {
74557       {
74558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74559       };
74560     }
74561   }
74562   jresult = (void *)result;
74563   return jresult;
74564 }
74565
74566
74567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74568   void * jresult ;
74569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74570   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74571
74572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74573   {
74574     try {
74575       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74576     } catch (std::out_of_range& e) {
74577       {
74578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74579       };
74580     } catch (std::exception& e) {
74581       {
74582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74583       };
74584     } catch (...) {
74585       {
74586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74587       };
74588     }
74589   }
74590   jresult = (void *)result;
74591   return jresult;
74592 }
74593
74594
74595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74596   void * jresult ;
74597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74598   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74599
74600   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74601   {
74602     try {
74603       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74604     } catch (std::out_of_range& e) {
74605       {
74606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74607       };
74608     } catch (std::exception& e) {
74609       {
74610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74611       };
74612     } catch (...) {
74613       {
74614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74615       };
74616     }
74617   }
74618   jresult = (void *)result;
74619   return jresult;
74620 }
74621
74622
74623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74624   void * jresult ;
74625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74626   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74627
74628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74629   {
74630     try {
74631       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74632     } catch (std::out_of_range& e) {
74633       {
74634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74635       };
74636     } catch (std::exception& e) {
74637       {
74638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74639       };
74640     } catch (...) {
74641       {
74642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74643       };
74644     }
74645   }
74646   jresult = (void *)result;
74647   return jresult;
74648 }
74649
74650
74651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74652   void * jresult ;
74653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74654   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74655
74656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74657   {
74658     try {
74659       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74667       };
74668     } catch (...) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74671       };
74672     }
74673   }
74674   jresult = (void *)result;
74675   return jresult;
74676 }
74677
74678
74679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74680   void * jresult ;
74681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74682   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74683
74684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74685   {
74686     try {
74687       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74688     } catch (std::out_of_range& e) {
74689       {
74690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74691       };
74692     } catch (std::exception& e) {
74693       {
74694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74695       };
74696     } catch (...) {
74697       {
74698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74699       };
74700     }
74701   }
74702   jresult = (void *)result;
74703   return jresult;
74704 }
74705
74706
74707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74708   void * jresult ;
74709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74710   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74711
74712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74713   {
74714     try {
74715       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74716     } catch (std::out_of_range& e) {
74717       {
74718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74719       };
74720     } catch (std::exception& e) {
74721       {
74722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74723       };
74724     } catch (...) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74727       };
74728     }
74729   }
74730   jresult = (void *)result;
74731   return jresult;
74732 }
74733
74734
74735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74736   void * jresult ;
74737   Dali::Toolkit::StyleManager *result = 0 ;
74738
74739   {
74740     try {
74741       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74749       };
74750     } catch (...) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74753       };
74754     }
74755   }
74756   jresult = (void *)result;
74757   return jresult;
74758 }
74759
74760
74761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74762   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74763
74764   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74765   {
74766     try {
74767       delete arg1;
74768     } catch (std::out_of_range& e) {
74769       {
74770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74771       };
74772     } catch (std::exception& e) {
74773       {
74774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74775       };
74776     } catch (...) {
74777       {
74778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74779       };
74780     }
74781   }
74782 }
74783
74784
74785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74786   void * jresult ;
74787   Dali::Toolkit::StyleManager result;
74788
74789   {
74790     try {
74791       result = Dali::Toolkit::StyleManager::Get();
74792     } catch (std::out_of_range& e) {
74793       {
74794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74795       };
74796     } catch (std::exception& e) {
74797       {
74798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74799       };
74800     } catch (...) {
74801       {
74802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74803       };
74804     }
74805   }
74806   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74807   return jresult;
74808 }
74809
74810
74811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74812   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74813   std::string *arg2 = 0 ;
74814
74815   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74816   if (!jarg2) {
74817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74818     return ;
74819   }
74820   std::string arg2_str(jarg2);
74821   arg2 = &arg2_str;
74822   {
74823     try {
74824       (arg1)->ApplyTheme((std::string const &)*arg2);
74825     } catch (std::out_of_range& e) {
74826       {
74827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74828       };
74829     } catch (std::exception& e) {
74830       {
74831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74832       };
74833     } catch (...) {
74834       {
74835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74836       };
74837     }
74838   }
74839
74840   //argout typemap for const std::string&
74841
74842 }
74843
74844
74845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74846   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74847
74848   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74849   {
74850     try {
74851       (arg1)->ApplyDefaultTheme();
74852     } catch (std::out_of_range& e) {
74853       {
74854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74855       };
74856     } catch (std::exception& e) {
74857       {
74858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74859       };
74860     } catch (...) {
74861       {
74862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74863       };
74864     }
74865   }
74866 }
74867
74868
74869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74870   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74871   std::string *arg2 = 0 ;
74872   Dali::Property::Value *arg3 = 0 ;
74873
74874   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74875   if (!jarg2) {
74876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74877     return ;
74878   }
74879   std::string arg2_str(jarg2);
74880   arg2 = &arg2_str;
74881   arg3 = (Dali::Property::Value *)jarg3;
74882   if (!arg3) {
74883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74884     return ;
74885   }
74886   {
74887     try {
74888       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74889     } catch (std::out_of_range& e) {
74890       {
74891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74892       };
74893     } catch (std::exception& e) {
74894       {
74895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74896       };
74897     } catch (...) {
74898       {
74899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74900       };
74901     }
74902   }
74903
74904   //argout typemap for const std::string&
74905
74906 }
74907
74908
74909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74910   unsigned int jresult ;
74911   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74912   std::string *arg2 = 0 ;
74913   Dali::Property::Value *arg3 = 0 ;
74914   bool result;
74915
74916   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74917   if (!jarg2) {
74918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74919     return 0;
74920   }
74921   std::string arg2_str(jarg2);
74922   arg2 = &arg2_str;
74923   arg3 = (Dali::Property::Value *)jarg3;
74924   if (!arg3) {
74925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74926     return 0;
74927   }
74928   {
74929     try {
74930       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74931     } catch (std::out_of_range& e) {
74932       {
74933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74934       };
74935     } catch (std::exception& e) {
74936       {
74937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74938       };
74939     } catch (...) {
74940       {
74941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74942       };
74943     }
74944   }
74945   jresult = result;
74946
74947   //argout typemap for const std::string&
74948
74949   return jresult;
74950 }
74951
74952
74953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74954   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74955   Dali::Toolkit::Control arg2 ;
74956   std::string *arg3 = 0 ;
74957   std::string *arg4 = 0 ;
74958   Dali::Toolkit::Control *argp2 ;
74959
74960   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74961   argp2 = (Dali::Toolkit::Control *)jarg2;
74962   if (!argp2) {
74963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74964     return ;
74965   }
74966   arg2 = *argp2;
74967   if (!jarg3) {
74968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74969     return ;
74970   }
74971   std::string arg3_str(jarg3);
74972   arg3 = &arg3_str;
74973   if (!jarg4) {
74974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74975     return ;
74976   }
74977   std::string arg4_str(jarg4);
74978   arg4 = &arg4_str;
74979   {
74980     try {
74981       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74982     } catch (std::out_of_range& e) {
74983       {
74984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74985       };
74986     } catch (std::exception& e) {
74987       {
74988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74989       };
74990     } catch (...) {
74991       {
74992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74993       };
74994     }
74995   }
74996
74997   //argout typemap for const std::string&
74998
74999
75000   //argout typemap for const std::string&
75001
75002 }
75003
75004
75005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
75006   void * jresult ;
75007   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
75008   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
75009
75010   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
75011   {
75012     try {
75013       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
75014     } catch (std::out_of_range& e) {
75015       {
75016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75017       };
75018     } catch (std::exception& e) {
75019       {
75020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75021       };
75022     } catch (...) {
75023       {
75024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75025       };
75026     }
75027   }
75028   jresult = (void *)result;
75029   return jresult;
75030 }
75031
75032
75033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
75034   int jresult ;
75035   int result;
75036
75037   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
75038   jresult = (int)result;
75039   return jresult;
75040 }
75041
75042
75043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75044   int jresult ;
75045   int result;
75046
75047   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75048   jresult = (int)result;
75049   return jresult;
75050 }
75051
75052
75053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75054   int jresult ;
75055   int result;
75056
75057   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75058   jresult = (int)result;
75059   return jresult;
75060 }
75061
75062
75063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75064   int jresult ;
75065   int result;
75066
75067   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75068   jresult = (int)result;
75069   return jresult;
75070 }
75071
75072
75073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75074   int jresult ;
75075   int result;
75076
75077   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75078   jresult = (int)result;
75079   return jresult;
75080 }
75081
75082
75083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75084   int jresult ;
75085   int result;
75086
75087   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75088   jresult = (int)result;
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75094   int jresult ;
75095   int result;
75096
75097   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75098   jresult = (int)result;
75099   return jresult;
75100 }
75101
75102
75103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75104   int jresult ;
75105   int result;
75106
75107   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75108   jresult = (int)result;
75109   return jresult;
75110 }
75111
75112
75113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75114   int jresult ;
75115   int result;
75116
75117   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75118   jresult = (int)result;
75119   return jresult;
75120 }
75121
75122
75123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75124   int jresult ;
75125   int result;
75126
75127   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75128   jresult = (int)result;
75129   return jresult;
75130 }
75131
75132
75133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75134   int jresult ;
75135   int result;
75136
75137   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75138   jresult = (int)result;
75139   return jresult;
75140 }
75141
75142
75143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75144   int jresult ;
75145   int result;
75146
75147   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75148   jresult = (int)result;
75149   return jresult;
75150 }
75151
75152
75153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75154   int jresult ;
75155   int result;
75156
75157   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75158   jresult = (int)result;
75159   return jresult;
75160 }
75161
75162
75163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75164   int jresult ;
75165   int result;
75166
75167   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75168   jresult = (int)result;
75169   return jresult;
75170 }
75171
75172
75173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75174   int jresult ;
75175   int result;
75176
75177   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75178   jresult = (int)result;
75179   return jresult;
75180 }
75181
75182
75183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75184   void * jresult ;
75185   Dali::Toolkit::Slider::Property *result = 0 ;
75186
75187   {
75188     try {
75189       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (...) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75201       };
75202     }
75203   }
75204   jresult = (void *)result;
75205   return jresult;
75206 }
75207
75208
75209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75210   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75211
75212   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75213   {
75214     try {
75215       delete arg1;
75216     } catch (std::out_of_range& e) {
75217       {
75218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75219       };
75220     } catch (std::exception& e) {
75221       {
75222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75227       };
75228     }
75229   }
75230 }
75231
75232
75233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75234   void * jresult ;
75235   Dali::Toolkit::Slider result;
75236
75237   {
75238     try {
75239       result = Dali::Toolkit::Slider::New();
75240     } catch (std::out_of_range& e) {
75241       {
75242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75243       };
75244     } catch (std::exception& e) {
75245       {
75246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75247       };
75248     } catch (...) {
75249       {
75250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75251       };
75252     }
75253   }
75254   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75255   return jresult;
75256 }
75257
75258
75259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75260   void * jresult ;
75261   Dali::Toolkit::Slider *result = 0 ;
75262
75263   {
75264     try {
75265       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75266     } catch (std::out_of_range& e) {
75267       {
75268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75269       };
75270     } catch (std::exception& e) {
75271       {
75272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75273       };
75274     } catch (...) {
75275       {
75276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75277       };
75278     }
75279   }
75280   jresult = (void *)result;
75281   return jresult;
75282 }
75283
75284
75285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75286   void * jresult ;
75287   Dali::Toolkit::Slider *arg1 = 0 ;
75288   Dali::Toolkit::Slider *result = 0 ;
75289
75290   arg1 = (Dali::Toolkit::Slider *)jarg1;
75291   if (!arg1) {
75292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75293     return 0;
75294   }
75295   {
75296     try {
75297       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75298     } catch (std::out_of_range& e) {
75299       {
75300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75301       };
75302     } catch (std::exception& e) {
75303       {
75304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75305       };
75306     } catch (...) {
75307       {
75308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75309       };
75310     }
75311   }
75312   jresult = (void *)result;
75313   return jresult;
75314 }
75315
75316
75317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75318   void * jresult ;
75319   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75320   Dali::Toolkit::Slider *arg2 = 0 ;
75321   Dali::Toolkit::Slider *result = 0 ;
75322
75323   arg1 = (Dali::Toolkit::Slider *)jarg1;
75324   arg2 = (Dali::Toolkit::Slider *)jarg2;
75325   if (!arg2) {
75326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75327     return 0;
75328   }
75329   {
75330     try {
75331       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75332     } catch (std::out_of_range& e) {
75333       {
75334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75335       };
75336     } catch (std::exception& e) {
75337       {
75338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75339       };
75340     } catch (...) {
75341       {
75342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75343       };
75344     }
75345   }
75346   jresult = (void *)result;
75347   return jresult;
75348 }
75349
75350
75351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75352   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75353
75354   arg1 = (Dali::Toolkit::Slider *)jarg1;
75355   {
75356     try {
75357       delete arg1;
75358     } catch (std::out_of_range& e) {
75359       {
75360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75361       };
75362     } catch (std::exception& e) {
75363       {
75364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75365       };
75366     } catch (...) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75369       };
75370     }
75371   }
75372 }
75373
75374
75375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75376   void * jresult ;
75377   Dali::BaseHandle arg1 ;
75378   Dali::BaseHandle *argp1 ;
75379   Dali::Toolkit::Slider result;
75380
75381   argp1 = (Dali::BaseHandle *)jarg1;
75382   if (!argp1) {
75383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75384     return 0;
75385   }
75386   arg1 = *argp1;
75387   {
75388     try {
75389       result = Dali::Toolkit::Slider::DownCast(arg1);
75390     } catch (std::out_of_range& e) {
75391       {
75392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (std::exception& e) {
75395       {
75396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75397       };
75398     } catch (...) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75401       };
75402     }
75403   }
75404   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75405   return jresult;
75406 }
75407
75408
75409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75410   void * jresult ;
75411   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75412   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75413
75414   arg1 = (Dali::Toolkit::Slider *)jarg1;
75415   {
75416     try {
75417       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75425       };
75426     } catch (...) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75429       };
75430     }
75431   }
75432   jresult = (void *)result;
75433   return jresult;
75434 }
75435
75436
75437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75438   void * jresult ;
75439   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75440   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75441
75442   arg1 = (Dali::Toolkit::Slider *)jarg1;
75443   {
75444     try {
75445       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75446     } catch (std::out_of_range& e) {
75447       {
75448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75449       };
75450     } catch (std::exception& e) {
75451       {
75452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75453       };
75454     } catch (...) {
75455       {
75456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75457       };
75458     }
75459   }
75460   jresult = (void *)result;
75461   return jresult;
75462 }
75463
75464
75465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75466   void * jresult ;
75467   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75468   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75469
75470   arg1 = (Dali::Toolkit::Slider *)jarg1;
75471   {
75472     try {
75473       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75474     } catch (std::out_of_range& e) {
75475       {
75476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75477       };
75478     } catch (std::exception& e) {
75479       {
75480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75481       };
75482     } catch (...) {
75483       {
75484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75485       };
75486     }
75487   }
75488   jresult = (void *)result;
75489   return jresult;
75490 }
75491
75492
75493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75494   int jresult ;
75495   int result;
75496
75497   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75498   jresult = (int)result;
75499   return jresult;
75500 }
75501
75502
75503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75504   int jresult ;
75505   int result;
75506
75507   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75508   jresult = (int)result;
75509   return jresult;
75510 }
75511
75512
75513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75514   int jresult ;
75515   int result;
75516
75517   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75518   jresult = (int)result;
75519   return jresult;
75520 }
75521
75522
75523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75524   int jresult ;
75525   int result;
75526
75527   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75528   jresult = (int)result;
75529   return jresult;
75530 }
75531
75532
75533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75534   void * jresult ;
75535   Dali::Toolkit::VideoView::Property *result = 0 ;
75536
75537   {
75538     try {
75539       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75540     } catch (std::out_of_range& e) {
75541       {
75542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75543       };
75544     } catch (std::exception& e) {
75545       {
75546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75547       };
75548     } catch (...) {
75549       {
75550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75551       };
75552     }
75553   }
75554   jresult = (void *)result;
75555   return jresult;
75556 }
75557
75558
75559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75560   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75561
75562   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75563   {
75564     try {
75565       delete arg1;
75566     } catch (std::out_of_range& e) {
75567       {
75568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75569       };
75570     } catch (std::exception& e) {
75571       {
75572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75573       };
75574     } catch (...) {
75575       {
75576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75577       };
75578     }
75579   }
75580 }
75581
75582
75583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75584   void * jresult ;
75585   Dali::Toolkit::VideoView result;
75586
75587   {
75588     try {
75589       result = Dali::Toolkit::VideoView::New();
75590     } catch (std::out_of_range& e) {
75591       {
75592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75593       };
75594     } catch (std::exception& e) {
75595       {
75596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75597       };
75598     } catch (...) {
75599       {
75600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75601       };
75602     }
75603   }
75604   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75605   return jresult;
75606 }
75607
75608
75609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75610   void * jresult ;
75611   std::string *arg1 = 0 ;
75612   Dali::Toolkit::VideoView result;
75613
75614   if (!jarg1) {
75615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75616     return 0;
75617   }
75618   std::string arg1_str(jarg1);
75619   arg1 = &arg1_str;
75620   {
75621     try {
75622       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75623     } catch (std::out_of_range& e) {
75624       {
75625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75626       };
75627     } catch (std::exception& e) {
75628       {
75629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75630       };
75631     } catch (...) {
75632       {
75633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75634       };
75635     }
75636   }
75637   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75638
75639   //argout typemap for const std::string&
75640
75641   return jresult;
75642 }
75643
75644
75645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75646   void * jresult ;
75647   Dali::Toolkit::VideoView *result = 0 ;
75648
75649   {
75650     try {
75651       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75652     } catch (std::out_of_range& e) {
75653       {
75654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75655       };
75656     } catch (std::exception& e) {
75657       {
75658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75659       };
75660     } catch (...) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75663       };
75664     }
75665   }
75666   jresult = (void *)result;
75667   return jresult;
75668 }
75669
75670
75671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75672   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75673
75674   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75675   {
75676     try {
75677       delete arg1;
75678     } catch (std::out_of_range& e) {
75679       {
75680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75681       };
75682     } catch (std::exception& e) {
75683       {
75684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75685       };
75686     } catch (...) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75689       };
75690     }
75691   }
75692 }
75693
75694
75695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75696   void * jresult ;
75697   Dali::Toolkit::VideoView *arg1 = 0 ;
75698   Dali::Toolkit::VideoView *result = 0 ;
75699
75700   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75701   if (!arg1) {
75702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75703     return 0;
75704   }
75705   {
75706     try {
75707       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75708     } catch (std::out_of_range& e) {
75709       {
75710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75711       };
75712     } catch (std::exception& e) {
75713       {
75714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75719       };
75720     }
75721   }
75722   jresult = (void *)result;
75723   return jresult;
75724 }
75725
75726
75727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75728   void * jresult ;
75729   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75730   Dali::Toolkit::VideoView *arg2 = 0 ;
75731   Dali::Toolkit::VideoView *result = 0 ;
75732
75733   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75734   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75735   if (!arg2) {
75736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75737     return 0;
75738   }
75739   {
75740     try {
75741       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75742     } catch (std::out_of_range& e) {
75743       {
75744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75745       };
75746     } catch (std::exception& e) {
75747       {
75748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75749       };
75750     } catch (...) {
75751       {
75752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75753       };
75754     }
75755   }
75756   jresult = (void *)result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75762   void * jresult ;
75763   Dali::BaseHandle arg1 ;
75764   Dali::BaseHandle *argp1 ;
75765   Dali::Toolkit::VideoView result;
75766
75767   argp1 = (Dali::BaseHandle *)jarg1;
75768   if (!argp1) {
75769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75770     return 0;
75771   }
75772   arg1 = *argp1;
75773   {
75774     try {
75775       result = Dali::Toolkit::VideoView::DownCast(arg1);
75776     } catch (std::out_of_range& e) {
75777       {
75778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75779       };
75780     } catch (std::exception& e) {
75781       {
75782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75783       };
75784     } catch (...) {
75785       {
75786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75787       };
75788     }
75789   }
75790   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75791   return jresult;
75792 }
75793
75794
75795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75796   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75797
75798   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75799   {
75800     try {
75801       (arg1)->Play();
75802     } catch (std::out_of_range& e) {
75803       {
75804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75805       };
75806     } catch (std::exception& e) {
75807       {
75808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75809       };
75810     } catch (...) {
75811       {
75812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75813       };
75814     }
75815   }
75816 }
75817
75818
75819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75820   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75821
75822   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75823   {
75824     try {
75825       (arg1)->Pause();
75826     } catch (std::out_of_range& e) {
75827       {
75828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75829       };
75830     } catch (std::exception& e) {
75831       {
75832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75833       };
75834     } catch (...) {
75835       {
75836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75837       };
75838     }
75839   }
75840 }
75841
75842
75843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75844   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75845
75846   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75847   {
75848     try {
75849       (arg1)->Stop();
75850     } catch (std::out_of_range& e) {
75851       {
75852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75853       };
75854     } catch (std::exception& e) {
75855       {
75856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (...) {
75859       {
75860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75861       };
75862     }
75863   }
75864 }
75865
75866
75867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75868   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75869   int arg2 ;
75870
75871   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75872   arg2 = (int)jarg2;
75873   {
75874     try {
75875       (arg1)->Forward(arg2);
75876     } catch (std::out_of_range& e) {
75877       {
75878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75879       };
75880     } catch (std::exception& e) {
75881       {
75882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75883       };
75884     } catch (...) {
75885       {
75886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75887       };
75888     }
75889   }
75890 }
75891
75892
75893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
75894   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75895   int arg2 ;
75896
75897   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75898   arg2 = (int)jarg2;
75899   {
75900     try {
75901       (arg1)->Backward(arg2);
75902     } catch (std::out_of_range& e) {
75903       {
75904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75905       };
75906     } catch (std::exception& e) {
75907       {
75908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75909       };
75910     } catch (...) {
75911       {
75912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75913       };
75914     }
75915   }
75916 }
75917
75918
75919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75920   void * jresult ;
75921   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75922   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75923
75924   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75925   {
75926     try {
75927       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75928     } catch (std::out_of_range& e) {
75929       {
75930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75931       };
75932     } catch (std::exception& e) {
75933       {
75934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75935       };
75936     } catch (...) {
75937       {
75938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75939       };
75940     }
75941   }
75942   jresult = (void *)result;
75943   return jresult;
75944 }
75945
75946
75947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75948   int jresult ;
75949   int result;
75950
75951   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75952   jresult = (int)result;
75953   return jresult;
75954 }
75955
75956
75957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75958   int jresult ;
75959   int result;
75960
75961   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75962   jresult = (int)result;
75963   return jresult;
75964 }
75965
75966
75967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75968   int jresult ;
75969   int result;
75970
75971   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75972   jresult = (int)result;
75973   return jresult;
75974 }
75975
75976
75977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75978   int jresult ;
75979   int result;
75980
75981   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75982   jresult = (int)result;
75983   return jresult;
75984 }
75985
75986
75987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75988   int jresult ;
75989   int result;
75990
75991   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75992   jresult = (int)result;
75993   return jresult;
75994 }
75995
75996
75997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75998   int jresult ;
75999   int result;
76000
76001   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
76002   jresult = (int)result;
76003   return jresult;
76004 }
76005
76006
76007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
76008   int jresult ;
76009   int result;
76010
76011   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
76012   jresult = (int)result;
76013   return jresult;
76014 }
76015
76016
76017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
76018   int jresult ;
76019   int result;
76020
76021   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
76022   jresult = (int)result;
76023   return jresult;
76024 }
76025
76026
76027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
76028   int jresult ;
76029   int result;
76030
76031   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
76032   jresult = (int)result;
76033   return jresult;
76034 }
76035
76036
76037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
76038   int jresult ;
76039   int result;
76040
76041   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
76042   jresult = (int)result;
76043   return jresult;
76044 }
76045
76046
76047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76048   int jresult ;
76049   int result;
76050
76051   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76052   jresult = (int)result;
76053   return jresult;
76054 }
76055
76056
76057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76058   int jresult ;
76059   int result;
76060
76061   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76062   jresult = (int)result;
76063   return jresult;
76064 }
76065
76066
76067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76068   int jresult ;
76069   int result;
76070
76071   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76072   jresult = (int)result;
76073   return jresult;
76074 }
76075
76076
76077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76078   int jresult ;
76079   int result;
76080
76081   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76082   jresult = (int)result;
76083   return jresult;
76084 }
76085
76086
76087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76088   int jresult ;
76089   int result;
76090
76091   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76092   jresult = (int)result;
76093   return jresult;
76094 }
76095
76096
76097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76098   int jresult ;
76099   int result;
76100
76101   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76102   jresult = (int)result;
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76108   int jresult ;
76109   int result;
76110
76111   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76112   jresult = (int)result;
76113   return jresult;
76114 }
76115
76116
76117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76118   int jresult ;
76119   int result;
76120
76121   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76122   jresult = (int)result;
76123   return jresult;
76124 }
76125
76126
76127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76128   int jresult ;
76129   int result;
76130
76131   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76132   jresult = (int)result;
76133   return jresult;
76134 }
76135
76136
76137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76138   int jresult ;
76139   int result;
76140
76141   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76142   jresult = (int)result;
76143   return jresult;
76144 }
76145
76146
76147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76148   int jresult ;
76149   int result;
76150
76151   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76152   jresult = (int)result;
76153   return jresult;
76154 }
76155
76156
76157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76158   void * jresult ;
76159   Dali::Toolkit::Popup::Property *result = 0 ;
76160
76161   {
76162     try {
76163       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76164     } catch (std::out_of_range& e) {
76165       {
76166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76167       };
76168     } catch (std::exception& e) {
76169       {
76170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76171       };
76172     } catch (...) {
76173       {
76174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76175       };
76176     }
76177   }
76178   jresult = (void *)result;
76179   return jresult;
76180 }
76181
76182
76183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76184   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76185
76186   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76187   {
76188     try {
76189       delete arg1;
76190     } catch (std::out_of_range& e) {
76191       {
76192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76193       };
76194     } catch (std::exception& e) {
76195       {
76196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76197       };
76198     } catch (...) {
76199       {
76200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76201       };
76202     }
76203   }
76204 }
76205
76206
76207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76208   void * jresult ;
76209   Dali::Toolkit::Popup *result = 0 ;
76210
76211   {
76212     try {
76213       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76214     } catch (std::out_of_range& e) {
76215       {
76216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76217       };
76218     } catch (std::exception& e) {
76219       {
76220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76221       };
76222     } catch (...) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76225       };
76226     }
76227   }
76228   jresult = (void *)result;
76229   return jresult;
76230 }
76231
76232
76233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76234   void * jresult ;
76235   Dali::Toolkit::Popup result;
76236
76237   {
76238     try {
76239       result = Dali::Toolkit::Popup::New();
76240     } catch (std::out_of_range& e) {
76241       {
76242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76243       };
76244     } catch (std::exception& e) {
76245       {
76246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76247       };
76248     } catch (...) {
76249       {
76250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76251       };
76252     }
76253   }
76254   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76255   return jresult;
76256 }
76257
76258
76259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76260   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76261
76262   arg1 = (Dali::Toolkit::Popup *)jarg1;
76263   {
76264     try {
76265       delete arg1;
76266     } catch (std::out_of_range& e) {
76267       {
76268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76269       };
76270     } catch (std::exception& e) {
76271       {
76272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76273       };
76274     } catch (...) {
76275       {
76276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76277       };
76278     }
76279   }
76280 }
76281
76282
76283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76284   void * jresult ;
76285   Dali::Toolkit::Popup *arg1 = 0 ;
76286   Dali::Toolkit::Popup *result = 0 ;
76287
76288   arg1 = (Dali::Toolkit::Popup *)jarg1;
76289   if (!arg1) {
76290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76291     return 0;
76292   }
76293   {
76294     try {
76295       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76296     } catch (std::out_of_range& e) {
76297       {
76298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76299       };
76300     } catch (std::exception& e) {
76301       {
76302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76307       };
76308     }
76309   }
76310   jresult = (void *)result;
76311   return jresult;
76312 }
76313
76314
76315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76316   void * jresult ;
76317   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76318   Dali::Toolkit::Popup *arg2 = 0 ;
76319   Dali::Toolkit::Popup *result = 0 ;
76320
76321   arg1 = (Dali::Toolkit::Popup *)jarg1;
76322   arg2 = (Dali::Toolkit::Popup *)jarg2;
76323   if (!arg2) {
76324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76325     return 0;
76326   }
76327   {
76328     try {
76329       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76330     } catch (std::out_of_range& e) {
76331       {
76332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76333       };
76334     } catch (std::exception& e) {
76335       {
76336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76337       };
76338     } catch (...) {
76339       {
76340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76341       };
76342     }
76343   }
76344   jresult = (void *)result;
76345   return jresult;
76346 }
76347
76348
76349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76350   void * jresult ;
76351   Dali::BaseHandle arg1 ;
76352   Dali::BaseHandle *argp1 ;
76353   Dali::Toolkit::Popup result;
76354
76355   argp1 = (Dali::BaseHandle *)jarg1;
76356   if (!argp1) {
76357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76358     return 0;
76359   }
76360   arg1 = *argp1;
76361   {
76362     try {
76363       result = Dali::Toolkit::Popup::DownCast(arg1);
76364     } catch (std::out_of_range& e) {
76365       {
76366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76367       };
76368     } catch (std::exception& e) {
76369       {
76370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76371       };
76372     } catch (...) {
76373       {
76374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76375       };
76376     }
76377   }
76378   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76379   return jresult;
76380 }
76381
76382
76383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76384   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76385   Dali::Actor arg2 ;
76386   Dali::Actor *argp2 ;
76387
76388   arg1 = (Dali::Toolkit::Popup *)jarg1;
76389   argp2 = (Dali::Actor *)jarg2;
76390   if (!argp2) {
76391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76392     return ;
76393   }
76394   arg2 = *argp2;
76395   {
76396     try {
76397       (arg1)->SetTitle(arg2);
76398     } catch (std::out_of_range& e) {
76399       {
76400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76401       };
76402     } catch (std::exception& e) {
76403       {
76404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76405       };
76406     } catch (...) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76409       };
76410     }
76411   }
76412 }
76413
76414
76415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76416   void * jresult ;
76417   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76418   Dali::Actor result;
76419
76420   arg1 = (Dali::Toolkit::Popup *)jarg1;
76421   {
76422     try {
76423       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76424     } catch (std::out_of_range& e) {
76425       {
76426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76427       };
76428     } catch (std::exception& e) {
76429       {
76430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76431       };
76432     } catch (...) {
76433       {
76434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76435       };
76436     }
76437   }
76438   jresult = new Dali::Actor((const Dali::Actor &)result);
76439   return jresult;
76440 }
76441
76442
76443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76444   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76445   Dali::Actor arg2 ;
76446   Dali::Actor *argp2 ;
76447
76448   arg1 = (Dali::Toolkit::Popup *)jarg1;
76449   argp2 = (Dali::Actor *)jarg2;
76450   if (!argp2) {
76451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76452     return ;
76453   }
76454   arg2 = *argp2;
76455   {
76456     try {
76457       (arg1)->SetContent(arg2);
76458     } catch (std::out_of_range& e) {
76459       {
76460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76461       };
76462     } catch (std::exception& e) {
76463       {
76464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76465       };
76466     } catch (...) {
76467       {
76468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76469       };
76470     }
76471   }
76472 }
76473
76474
76475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76476   void * jresult ;
76477   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76478   Dali::Actor result;
76479
76480   arg1 = (Dali::Toolkit::Popup *)jarg1;
76481   {
76482     try {
76483       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76484     } catch (std::out_of_range& e) {
76485       {
76486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76487       };
76488     } catch (std::exception& e) {
76489       {
76490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76491       };
76492     } catch (...) {
76493       {
76494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76495       };
76496     }
76497   }
76498   jresult = new Dali::Actor((const Dali::Actor &)result);
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76504   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76505   Dali::Actor arg2 ;
76506   Dali::Actor *argp2 ;
76507
76508   arg1 = (Dali::Toolkit::Popup *)jarg1;
76509   argp2 = (Dali::Actor *)jarg2;
76510   if (!argp2) {
76511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76512     return ;
76513   }
76514   arg2 = *argp2;
76515   {
76516     try {
76517       (arg1)->SetFooter(arg2);
76518     } catch (std::out_of_range& e) {
76519       {
76520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76521       };
76522     } catch (std::exception& e) {
76523       {
76524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76525       };
76526     } catch (...) {
76527       {
76528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76529       };
76530     }
76531   }
76532 }
76533
76534
76535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76536   void * jresult ;
76537   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76538   Dali::Actor result;
76539
76540   arg1 = (Dali::Toolkit::Popup *)jarg1;
76541   {
76542     try {
76543       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76544     } catch (std::out_of_range& e) {
76545       {
76546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76547       };
76548     } catch (std::exception& e) {
76549       {
76550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76551       };
76552     } catch (...) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76555       };
76556     }
76557   }
76558   jresult = new Dali::Actor((const Dali::Actor &)result);
76559   return jresult;
76560 }
76561
76562
76563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76564   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76565   Dali::Toolkit::Popup::DisplayState arg2 ;
76566
76567   arg1 = (Dali::Toolkit::Popup *)jarg1;
76568   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76569   {
76570     try {
76571       (arg1)->SetDisplayState(arg2);
76572     } catch (std::out_of_range& e) {
76573       {
76574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76575       };
76576     } catch (std::exception& e) {
76577       {
76578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76579       };
76580     } catch (...) {
76581       {
76582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76583       };
76584     }
76585   }
76586 }
76587
76588
76589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76590   int jresult ;
76591   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76592   Dali::Toolkit::Popup::DisplayState result;
76593
76594   arg1 = (Dali::Toolkit::Popup *)jarg1;
76595   {
76596     try {
76597       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76598     } catch (std::out_of_range& e) {
76599       {
76600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76601       };
76602     } catch (std::exception& e) {
76603       {
76604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76605       };
76606     } catch (...) {
76607       {
76608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76609       };
76610     }
76611   }
76612   jresult = (int)result;
76613   return jresult;
76614 }
76615
76616
76617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76618   void * jresult ;
76619   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76620   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76621
76622   arg1 = (Dali::Toolkit::Popup *)jarg1;
76623   {
76624     try {
76625       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76626     } catch (std::out_of_range& e) {
76627       {
76628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76629       };
76630     } catch (std::exception& e) {
76631       {
76632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76633       };
76634     } catch (...) {
76635       {
76636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76637       };
76638     }
76639   }
76640   jresult = (void *)result;
76641   return jresult;
76642 }
76643
76644
76645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76646   void * jresult ;
76647   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76648   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76649
76650   arg1 = (Dali::Toolkit::Popup *)jarg1;
76651   {
76652     try {
76653       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76654     } catch (std::out_of_range& e) {
76655       {
76656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76657       };
76658     } catch (std::exception& e) {
76659       {
76660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76661       };
76662     } catch (...) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76665       };
76666     }
76667   }
76668   jresult = (void *)result;
76669   return jresult;
76670 }
76671
76672
76673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76674   void * jresult ;
76675   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76676   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76677
76678   arg1 = (Dali::Toolkit::Popup *)jarg1;
76679   {
76680     try {
76681       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76682     } catch (std::out_of_range& e) {
76683       {
76684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76685       };
76686     } catch (std::exception& e) {
76687       {
76688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76689       };
76690     } catch (...) {
76691       {
76692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76693       };
76694     }
76695   }
76696   jresult = (void *)result;
76697   return jresult;
76698 }
76699
76700
76701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76702   void * jresult ;
76703   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76704   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76705
76706   arg1 = (Dali::Toolkit::Popup *)jarg1;
76707   {
76708     try {
76709       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76710     } catch (std::out_of_range& e) {
76711       {
76712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76713       };
76714     } catch (std::exception& e) {
76715       {
76716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76717       };
76718     } catch (...) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76721       };
76722     }
76723   }
76724   jresult = (void *)result;
76725   return jresult;
76726 }
76727
76728
76729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76730   void * jresult ;
76731   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76732   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76733
76734   arg1 = (Dali::Toolkit::Popup *)jarg1;
76735   {
76736     try {
76737       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76738     } catch (std::out_of_range& e) {
76739       {
76740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76741       };
76742     } catch (std::exception& e) {
76743       {
76744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76745       };
76746     } catch (...) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76749       };
76750     }
76751   }
76752   jresult = (void *)result;
76753   return jresult;
76754 }
76755
76756
76757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76758   int jresult ;
76759   int result;
76760
76761   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76762   jresult = (int)result;
76763   return jresult;
76764 }
76765
76766
76767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76768   int jresult ;
76769   int result;
76770
76771   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76772   jresult = (int)result;
76773   return jresult;
76774 }
76775
76776
76777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76778   int jresult ;
76779   int result;
76780
76781   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76782   jresult = (int)result;
76783   return jresult;
76784 }
76785
76786
76787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76788   int jresult ;
76789   int result;
76790
76791   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76792   jresult = (int)result;
76793   return jresult;
76794 }
76795
76796
76797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76798   int jresult ;
76799   int result;
76800
76801   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76802   jresult = (int)result;
76803   return jresult;
76804 }
76805
76806
76807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76808   int jresult ;
76809   int result;
76810
76811   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76812   jresult = (int)result;
76813   return jresult;
76814 }
76815
76816
76817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76818   int jresult ;
76819   int result;
76820
76821   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76822   jresult = (int)result;
76823   return jresult;
76824 }
76825
76826
76827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76828   int jresult ;
76829   int result;
76830
76831   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76832   jresult = (int)result;
76833   return jresult;
76834 }
76835
76836
76837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76838   int jresult ;
76839   int result;
76840
76841   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76842   jresult = (int)result;
76843   return jresult;
76844 }
76845
76846
76847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76848   void * jresult ;
76849   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76850
76851   {
76852     try {
76853       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76854     } catch (std::out_of_range& e) {
76855       {
76856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76857       };
76858     } catch (std::exception& e) {
76859       {
76860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76861       };
76862     } catch (...) {
76863       {
76864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76865       };
76866     }
76867   }
76868   jresult = (void *)result;
76869   return jresult;
76870 }
76871
76872
76873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
76874   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76875
76876   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76877   {
76878     try {
76879       delete arg1;
76880     } catch (std::out_of_range& e) {
76881       {
76882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76883       };
76884     } catch (std::exception& e) {
76885       {
76886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76887       };
76888     } catch (...) {
76889       {
76890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76891       };
76892     }
76893   }
76894 }
76895
76896
76897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76898   void * jresult ;
76899   Dali::Toolkit::ProgressBar result;
76900
76901   {
76902     try {
76903       result = Dali::Toolkit::ProgressBar::New();
76904     } catch (std::out_of_range& e) {
76905       {
76906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76907       };
76908     } catch (std::exception& e) {
76909       {
76910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76911       };
76912     } catch (...) {
76913       {
76914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76915       };
76916     }
76917   }
76918   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76919   return jresult;
76920 }
76921
76922
76923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76924   void * jresult ;
76925   Dali::Toolkit::ProgressBar *result = 0 ;
76926
76927   {
76928     try {
76929       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76930     } catch (std::out_of_range& e) {
76931       {
76932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76933       };
76934     } catch (std::exception& e) {
76935       {
76936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76937       };
76938     } catch (...) {
76939       {
76940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76941       };
76942     }
76943   }
76944   jresult = (void *)result;
76945   return jresult;
76946 }
76947
76948
76949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76950   void * jresult ;
76951   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76952   Dali::Toolkit::ProgressBar *result = 0 ;
76953
76954   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76955   if (!arg1) {
76956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76957     return 0;
76958   }
76959   {
76960     try {
76961       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76962     } catch (std::out_of_range& e) {
76963       {
76964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76965       };
76966     } catch (std::exception& e) {
76967       {
76968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76969       };
76970     } catch (...) {
76971       {
76972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76973       };
76974     }
76975   }
76976   jresult = (void *)result;
76977   return jresult;
76978 }
76979
76980
76981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76982   void * jresult ;
76983   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76984   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76985   Dali::Toolkit::ProgressBar *result = 0 ;
76986
76987   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76988   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76989   if (!arg2) {
76990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76991     return 0;
76992   }
76993   {
76994     try {
76995       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
76996     } catch (std::out_of_range& e) {
76997       {
76998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76999       };
77000     } catch (std::exception& e) {
77001       {
77002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77003       };
77004     } catch (...) {
77005       {
77006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77007       };
77008     }
77009   }
77010   jresult = (void *)result;
77011   return jresult;
77012 }
77013
77014
77015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
77016   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77017
77018   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77019   {
77020     try {
77021       delete arg1;
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77029       };
77030     } catch (...) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77033       };
77034     }
77035   }
77036 }
77037
77038
77039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
77040   void * jresult ;
77041   Dali::BaseHandle arg1 ;
77042   Dali::BaseHandle *argp1 ;
77043   Dali::Toolkit::ProgressBar result;
77044
77045   argp1 = (Dali::BaseHandle *)jarg1;
77046   if (!argp1) {
77047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77048     return 0;
77049   }
77050   arg1 = *argp1;
77051   {
77052     try {
77053       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77054     } catch (std::out_of_range& e) {
77055       {
77056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77057       };
77058     } catch (std::exception& e) {
77059       {
77060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77061       };
77062     } catch (...) {
77063       {
77064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77065       };
77066     }
77067   }
77068   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77069   return jresult;
77070 }
77071
77072
77073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77074   void * jresult ;
77075   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77076   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77077
77078   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77079   {
77080     try {
77081       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77082     } catch (std::out_of_range& e) {
77083       {
77084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77085       };
77086     } catch (std::exception& e) {
77087       {
77088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77089       };
77090     } catch (...) {
77091       {
77092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77093       };
77094     }
77095   }
77096   jresult = (void *)result;
77097   return jresult;
77098 }
77099
77100
77101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77102   void * jresult ;
77103   Dali::Toolkit::GaussianBlurView *result = 0 ;
77104
77105   {
77106     try {
77107       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77108     } catch (std::out_of_range& e) {
77109       {
77110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77111       };
77112     } catch (std::exception& e) {
77113       {
77114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77115       };
77116     } catch (...) {
77117       {
77118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77119       };
77120     }
77121   }
77122   jresult = (void *)result;
77123   return jresult;
77124 }
77125
77126
77127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77128   void * jresult ;
77129   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77130   Dali::Toolkit::GaussianBlurView *result = 0 ;
77131
77132   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77133   if (!arg1) {
77134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77135     return 0;
77136   }
77137   {
77138     try {
77139       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77140     } catch (std::out_of_range& e) {
77141       {
77142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77143       };
77144     } catch (std::exception& e) {
77145       {
77146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77147       };
77148     } catch (...) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77151       };
77152     }
77153   }
77154   jresult = (void *)result;
77155   return jresult;
77156 }
77157
77158
77159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77160   void * jresult ;
77161   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77162   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77163   Dali::Toolkit::GaussianBlurView *result = 0 ;
77164
77165   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77166   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77167   if (!arg2) {
77168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77169     return 0;
77170   }
77171   {
77172     try {
77173       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77174     } catch (std::out_of_range& e) {
77175       {
77176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77177       };
77178     } catch (std::exception& e) {
77179       {
77180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77181       };
77182     } catch (...) {
77183       {
77184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77185       };
77186     }
77187   }
77188   jresult = (void *)result;
77189   return jresult;
77190 }
77191
77192
77193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77194   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77195
77196   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77197   {
77198     try {
77199       delete arg1;
77200     } catch (std::out_of_range& e) {
77201       {
77202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77203       };
77204     } catch (std::exception& e) {
77205       {
77206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77207       };
77208     } catch (...) {
77209       {
77210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77211       };
77212     }
77213   }
77214 }
77215
77216
77217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77218   void * jresult ;
77219   Dali::BaseHandle arg1 ;
77220   Dali::BaseHandle *argp1 ;
77221   Dali::Toolkit::GaussianBlurView result;
77222
77223   argp1 = (Dali::BaseHandle *)jarg1;
77224   if (!argp1) {
77225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77226     return 0;
77227   }
77228   arg1 = *argp1;
77229   {
77230     try {
77231       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77232     } catch (std::out_of_range& e) {
77233       {
77234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77235       };
77236     } catch (std::exception& e) {
77237       {
77238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77239       };
77240     } catch (...) {
77241       {
77242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77243       };
77244     }
77245   }
77246   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77247   return jresult;
77248 }
77249
77250
77251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77252   void * jresult ;
77253   Dali::Toolkit::GaussianBlurView result;
77254
77255   {
77256     try {
77257       result = Dali::Toolkit::GaussianBlurView::New();
77258     } catch (std::out_of_range& e) {
77259       {
77260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77261       };
77262     } catch (std::exception& e) {
77263       {
77264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77265       };
77266     } catch (...) {
77267       {
77268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77269       };
77270     }
77271   }
77272   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77273   return jresult;
77274 }
77275
77276
77277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77278   void * jresult ;
77279   unsigned int arg1 ;
77280   float arg2 ;
77281   Dali::Pixel::Format arg3 ;
77282   float arg4 ;
77283   float arg5 ;
77284   bool arg6 ;
77285   Dali::Toolkit::GaussianBlurView result;
77286
77287   arg1 = (unsigned int)jarg1;
77288   arg2 = (float)jarg2;
77289   arg3 = (Dali::Pixel::Format)jarg3;
77290   arg4 = (float)jarg4;
77291   arg5 = (float)jarg5;
77292   arg6 = jarg6 ? true : false;
77293   {
77294     try {
77295       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77296     } catch (std::out_of_range& e) {
77297       {
77298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77299       };
77300     } catch (std::exception& e) {
77301       {
77302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77303       };
77304     } catch (...) {
77305       {
77306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77307       };
77308     }
77309   }
77310   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77311   return jresult;
77312 }
77313
77314
77315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77316   void * jresult ;
77317   unsigned int arg1 ;
77318   float arg2 ;
77319   Dali::Pixel::Format arg3 ;
77320   float arg4 ;
77321   float arg5 ;
77322   Dali::Toolkit::GaussianBlurView result;
77323
77324   arg1 = (unsigned int)jarg1;
77325   arg2 = (float)jarg2;
77326   arg3 = (Dali::Pixel::Format)jarg3;
77327   arg4 = (float)jarg4;
77328   arg5 = (float)jarg5;
77329   {
77330     try {
77331       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77332     } catch (std::out_of_range& e) {
77333       {
77334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77335       };
77336     } catch (std::exception& e) {
77337       {
77338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77339       };
77340     } catch (...) {
77341       {
77342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77343       };
77344     }
77345   }
77346   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77347   return jresult;
77348 }
77349
77350
77351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77353   Dali::Actor arg2 ;
77354   Dali::Actor *argp2 ;
77355
77356   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77357   argp2 = (Dali::Actor *)jarg2;
77358   if (!argp2) {
77359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77360     return ;
77361   }
77362   arg2 = *argp2;
77363   {
77364     try {
77365       (arg1)->Add(arg2);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77373       };
77374     } catch (...) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77377       };
77378     }
77379   }
77380 }
77381
77382
77383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77384   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77385   Dali::Actor arg2 ;
77386   Dali::Actor *argp2 ;
77387
77388   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77389   argp2 = (Dali::Actor *)jarg2;
77390   if (!argp2) {
77391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77392     return ;
77393   }
77394   arg2 = *argp2;
77395   {
77396     try {
77397       (arg1)->Remove(arg2);
77398     } catch (std::out_of_range& e) {
77399       {
77400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77401       };
77402     } catch (std::exception& e) {
77403       {
77404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77405       };
77406     } catch (...) {
77407       {
77408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77409       };
77410     }
77411   }
77412 }
77413
77414
77415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77416   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77417
77418   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77419   {
77420     try {
77421       (arg1)->Activate();
77422     } catch (std::out_of_range& e) {
77423       {
77424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77425       };
77426     } catch (std::exception& e) {
77427       {
77428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77429       };
77430     } catch (...) {
77431       {
77432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77433       };
77434     }
77435   }
77436 }
77437
77438
77439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77440   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77441
77442   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77443   {
77444     try {
77445       (arg1)->ActivateOnce();
77446     } catch (std::out_of_range& e) {
77447       {
77448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77449       };
77450     } catch (std::exception& e) {
77451       {
77452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77453       };
77454     } catch (...) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77457       };
77458     }
77459   }
77460 }
77461
77462
77463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77464   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77465
77466   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77467   {
77468     try {
77469       (arg1)->Deactivate();
77470     } catch (std::out_of_range& e) {
77471       {
77472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77473       };
77474     } catch (std::exception& e) {
77475       {
77476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77477       };
77478     } catch (...) {
77479       {
77480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77481       };
77482     }
77483   }
77484 }
77485
77486
77487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77488   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77489   Dali::Image arg2 ;
77490   Dali::FrameBufferImage arg3 ;
77491   Dali::Image *argp2 ;
77492   Dali::FrameBufferImage *argp3 ;
77493
77494   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77495   argp2 = (Dali::Image *)jarg2;
77496   if (!argp2) {
77497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77498     return ;
77499   }
77500   arg2 = *argp2;
77501   argp3 = (Dali::FrameBufferImage *)jarg3;
77502   if (!argp3) {
77503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77504     return ;
77505   }
77506   arg3 = *argp3;
77507   {
77508     try {
77509       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77510     } catch (std::out_of_range& e) {
77511       {
77512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77513       };
77514     } catch (std::exception& e) {
77515       {
77516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77517       };
77518     } catch (...) {
77519       {
77520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77521       };
77522     }
77523   }
77524 }
77525
77526
77527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77528   int jresult ;
77529   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77530   Dali::Property::Index result;
77531
77532   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77533   {
77534     try {
77535       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77536     } catch (std::out_of_range& e) {
77537       {
77538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77539       };
77540     } catch (std::exception& e) {
77541       {
77542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77543       };
77544     } catch (...) {
77545       {
77546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77547       };
77548     }
77549   }
77550   jresult = result;
77551   return jresult;
77552 }
77553
77554
77555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77556   void * jresult ;
77557   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77558   Dali::FrameBufferImage result;
77559
77560   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77561   {
77562     try {
77563       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77571       };
77572     } catch (...) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77575       };
77576     }
77577   }
77578   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77579   return jresult;
77580 }
77581
77582
77583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77584   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77585   Dali::Vector4 *arg2 = 0 ;
77586
77587   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77588   arg2 = (Dali::Vector4 *)jarg2;
77589   if (!arg2) {
77590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77591     return ;
77592   }
77593   {
77594     try {
77595       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77596     } catch (std::out_of_range& e) {
77597       {
77598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77599       };
77600     } catch (std::exception& e) {
77601       {
77602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77603       };
77604     } catch (...) {
77605       {
77606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77607       };
77608     }
77609   }
77610 }
77611
77612
77613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77614   void * jresult ;
77615   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77616   Dali::Vector4 result;
77617
77618   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77619   {
77620     try {
77621       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77622     } catch (std::out_of_range& e) {
77623       {
77624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77625       };
77626     } catch (std::exception& e) {
77627       {
77628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77629       };
77630     } catch (...) {
77631       {
77632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77633       };
77634     }
77635   }
77636   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77637   return jresult;
77638 }
77639
77640
77641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77642   void * jresult ;
77643   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77644   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77645
77646   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77647   {
77648     try {
77649       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77650     } catch (std::out_of_range& e) {
77651       {
77652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77653       };
77654     } catch (std::exception& e) {
77655       {
77656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77657       };
77658     } catch (...) {
77659       {
77660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77661       };
77662     }
77663   }
77664   jresult = (void *)result;
77665   return jresult;
77666 }
77667
77668
77669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77670   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77671
77672   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77673   {
77674     try {
77675       delete arg1;
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77687       };
77688     }
77689   }
77690 }
77691
77692
77693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77694   unsigned int jresult ;
77695   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77696   unsigned int result;
77697
77698   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77699   {
77700     try {
77701       result = (unsigned int)(arg1)->GetNumberOfPages();
77702     } catch (std::out_of_range& e) {
77703       {
77704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77705       };
77706     } catch (std::exception& e) {
77707       {
77708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77709       };
77710     } catch (...) {
77711       {
77712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77713       };
77714     }
77715   }
77716   jresult = result;
77717   return jresult;
77718 }
77719
77720
77721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77722   void * jresult ;
77723   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77724   unsigned int arg2 ;
77725   Dali::Texture result;
77726
77727   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77728   arg2 = (unsigned int)jarg2;
77729   {
77730     try {
77731       result = (arg1)->NewPage(arg2);
77732     } catch (std::out_of_range& e) {
77733       {
77734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77735       };
77736     } catch (std::exception& e) {
77737       {
77738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77739       };
77740     } catch (...) {
77741       {
77742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77743       };
77744     }
77745   }
77746   jresult = new Dali::Texture((const Dali::Texture &)result);
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77752   int jresult ;
77753   int result;
77754
77755   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77756   jresult = (int)result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77762   int jresult ;
77763   int result;
77764
77765   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77766   jresult = (int)result;
77767   return jresult;
77768 }
77769
77770
77771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77772   int jresult ;
77773   int result;
77774
77775   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77776   jresult = (int)result;
77777   return jresult;
77778 }
77779
77780
77781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77782   void * jresult ;
77783   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77784
77785   {
77786     try {
77787       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77788     } catch (std::out_of_range& e) {
77789       {
77790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (std::exception& e) {
77793       {
77794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77795       };
77796     } catch (...) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77799       };
77800     }
77801   }
77802   jresult = (void *)result;
77803   return jresult;
77804 }
77805
77806
77807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77808   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77809
77810   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77811   {
77812     try {
77813       delete arg1;
77814     } catch (std::out_of_range& e) {
77815       {
77816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77817       };
77818     } catch (std::exception& e) {
77819       {
77820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77821       };
77822     } catch (...) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77825       };
77826     }
77827   }
77828 }
77829
77830
77831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77832   void * jresult ;
77833   Dali::Toolkit::PageTurnView *result = 0 ;
77834
77835   {
77836     try {
77837       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77838     } catch (std::out_of_range& e) {
77839       {
77840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77841       };
77842     } catch (std::exception& e) {
77843       {
77844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77845       };
77846     } catch (...) {
77847       {
77848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77849       };
77850     }
77851   }
77852   jresult = (void *)result;
77853   return jresult;
77854 }
77855
77856
77857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77858   void * jresult ;
77859   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77860   Dali::Toolkit::PageTurnView *result = 0 ;
77861
77862   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77863   if (!arg1) {
77864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77865     return 0;
77866   }
77867   {
77868     try {
77869       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77870     } catch (std::out_of_range& e) {
77871       {
77872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77873       };
77874     } catch (std::exception& e) {
77875       {
77876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77877       };
77878     } catch (...) {
77879       {
77880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77881       };
77882     }
77883   }
77884   jresult = (void *)result;
77885   return jresult;
77886 }
77887
77888
77889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77890   void * jresult ;
77891   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77892   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77893   Dali::Toolkit::PageTurnView *result = 0 ;
77894
77895   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77896   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77897   if (!arg2) {
77898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77899     return 0;
77900   }
77901   {
77902     try {
77903       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77904     } catch (std::out_of_range& e) {
77905       {
77906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77907       };
77908     } catch (std::exception& e) {
77909       {
77910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77911       };
77912     } catch (...) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77915       };
77916     }
77917   }
77918   jresult = (void *)result;
77919   return jresult;
77920 }
77921
77922
77923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77924   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77925
77926   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77927   {
77928     try {
77929       delete arg1;
77930     } catch (std::out_of_range& e) {
77931       {
77932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77933       };
77934     } catch (std::exception& e) {
77935       {
77936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77937       };
77938     } catch (...) {
77939       {
77940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77941       };
77942     }
77943   }
77944 }
77945
77946
77947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77948   void * jresult ;
77949   Dali::BaseHandle arg1 ;
77950   Dali::BaseHandle *argp1 ;
77951   Dali::Toolkit::PageTurnView result;
77952
77953   argp1 = (Dali::BaseHandle *)jarg1;
77954   if (!argp1) {
77955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77956     return 0;
77957   }
77958   arg1 = *argp1;
77959   {
77960     try {
77961       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
77962     } catch (std::out_of_range& e) {
77963       {
77964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77965       };
77966     } catch (std::exception& e) {
77967       {
77968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77969       };
77970     } catch (...) {
77971       {
77972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77973       };
77974     }
77975   }
77976   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77977   return jresult;
77978 }
77979
77980
77981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77982   void * jresult ;
77983   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77984   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77985
77986   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77987   {
77988     try {
77989       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77990     } catch (std::out_of_range& e) {
77991       {
77992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (std::exception& e) {
77995       {
77996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77997       };
77998     } catch (...) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78001       };
78002     }
78003   }
78004   jresult = (void *)result;
78005   return jresult;
78006 }
78007
78008
78009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
78010   void * jresult ;
78011   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78012   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
78013
78014   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78015   {
78016     try {
78017       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
78018     } catch (std::out_of_range& e) {
78019       {
78020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78021       };
78022     } catch (std::exception& e) {
78023       {
78024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78025       };
78026     } catch (...) {
78027       {
78028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78029       };
78030     }
78031   }
78032   jresult = (void *)result;
78033   return jresult;
78034 }
78035
78036
78037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
78038   void * jresult ;
78039   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78040   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78041
78042   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78043   {
78044     try {
78045       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78046     } catch (std::out_of_range& e) {
78047       {
78048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78049       };
78050     } catch (std::exception& e) {
78051       {
78052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78053       };
78054     } catch (...) {
78055       {
78056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78057       };
78058     }
78059   }
78060   jresult = (void *)result;
78061   return jresult;
78062 }
78063
78064
78065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78066   void * jresult ;
78067   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78068   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78069
78070   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78071   {
78072     try {
78073       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78074     } catch (std::out_of_range& e) {
78075       {
78076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78077       };
78078     } catch (std::exception& e) {
78079       {
78080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78081       };
78082     } catch (...) {
78083       {
78084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78085       };
78086     }
78087   }
78088   jresult = (void *)result;
78089   return jresult;
78090 }
78091
78092
78093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78094   void * jresult ;
78095   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78096
78097   {
78098     try {
78099       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78111       };
78112     }
78113   }
78114   jresult = (void *)result;
78115   return jresult;
78116 }
78117
78118
78119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78120   void * jresult ;
78121   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78122   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78123
78124   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78125   if (!arg1) {
78126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78127     return 0;
78128   }
78129   {
78130     try {
78131       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78132     } catch (std::out_of_range& e) {
78133       {
78134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78135       };
78136     } catch (std::exception& e) {
78137       {
78138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78139       };
78140     } catch (...) {
78141       {
78142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78143       };
78144     }
78145   }
78146   jresult = (void *)result;
78147   return jresult;
78148 }
78149
78150
78151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78152   void * jresult ;
78153   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78154   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78155   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78156
78157   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78158   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78159   if (!arg2) {
78160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78161     return 0;
78162   }
78163   {
78164     try {
78165       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78166     } catch (std::out_of_range& e) {
78167       {
78168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78169       };
78170     } catch (std::exception& e) {
78171       {
78172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (...) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78177       };
78178     }
78179   }
78180   jresult = (void *)result;
78181   return jresult;
78182 }
78183
78184
78185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78186   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78187
78188   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78189   {
78190     try {
78191       delete arg1;
78192     } catch (std::out_of_range& e) {
78193       {
78194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78195       };
78196     } catch (std::exception& e) {
78197       {
78198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78199       };
78200     } catch (...) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78203       };
78204     }
78205   }
78206 }
78207
78208
78209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78210   void * jresult ;
78211   Dali::Toolkit::PageFactory *arg1 = 0 ;
78212   Dali::Vector2 *arg2 = 0 ;
78213   Dali::Toolkit::PageTurnLandscapeView result;
78214
78215   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78216   if (!arg1) {
78217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78218     return 0;
78219   }
78220   arg2 = (Dali::Vector2 *)jarg2;
78221   if (!arg2) {
78222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78223     return 0;
78224   }
78225   {
78226     try {
78227       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78228     } catch (std::out_of_range& e) {
78229       {
78230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78231       };
78232     } catch (std::exception& e) {
78233       {
78234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78235       };
78236     } catch (...) {
78237       {
78238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78239       };
78240     }
78241   }
78242   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78248   void * jresult ;
78249   Dali::BaseHandle arg1 ;
78250   Dali::BaseHandle *argp1 ;
78251   Dali::Toolkit::PageTurnLandscapeView result;
78252
78253   argp1 = (Dali::BaseHandle *)jarg1;
78254   if (!argp1) {
78255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78256     return 0;
78257   }
78258   arg1 = *argp1;
78259   {
78260     try {
78261       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78262     } catch (std::out_of_range& e) {
78263       {
78264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78265       };
78266     } catch (std::exception& e) {
78267       {
78268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78269       };
78270     } catch (...) {
78271       {
78272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78273       };
78274     }
78275   }
78276   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78277   return jresult;
78278 }
78279
78280
78281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78282   void * jresult ;
78283   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78284
78285   {
78286     try {
78287       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78288     } catch (std::out_of_range& e) {
78289       {
78290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78291       };
78292     } catch (std::exception& e) {
78293       {
78294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78295       };
78296     } catch (...) {
78297       {
78298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78299       };
78300     }
78301   }
78302   jresult = (void *)result;
78303   return jresult;
78304 }
78305
78306
78307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78308   void * jresult ;
78309   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78310   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78311
78312   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78313   if (!arg1) {
78314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78315     return 0;
78316   }
78317   {
78318     try {
78319       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78320     } catch (std::out_of_range& e) {
78321       {
78322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78323       };
78324     } catch (std::exception& e) {
78325       {
78326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78327       };
78328     } catch (...) {
78329       {
78330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78331       };
78332     }
78333   }
78334   jresult = (void *)result;
78335   return jresult;
78336 }
78337
78338
78339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78340   void * jresult ;
78341   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78342   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78343   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78344
78345   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78346   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78347   if (!arg2) {
78348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78349     return 0;
78350   }
78351   {
78352     try {
78353       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78354     } catch (std::out_of_range& e) {
78355       {
78356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78357       };
78358     } catch (std::exception& e) {
78359       {
78360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78361       };
78362     } catch (...) {
78363       {
78364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78365       };
78366     }
78367   }
78368   jresult = (void *)result;
78369   return jresult;
78370 }
78371
78372
78373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78374   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78375
78376   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78377   {
78378     try {
78379       delete arg1;
78380     } catch (std::out_of_range& e) {
78381       {
78382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78383       };
78384     } catch (std::exception& e) {
78385       {
78386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78387       };
78388     } catch (...) {
78389       {
78390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78391       };
78392     }
78393   }
78394 }
78395
78396
78397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78398   void * jresult ;
78399   Dali::Toolkit::PageFactory *arg1 = 0 ;
78400   Dali::Vector2 *arg2 = 0 ;
78401   Dali::Toolkit::PageTurnPortraitView result;
78402
78403   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78404   if (!arg1) {
78405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78406     return 0;
78407   }
78408   arg2 = (Dali::Vector2 *)jarg2;
78409   if (!arg2) {
78410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78411     return 0;
78412   }
78413   {
78414     try {
78415       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78416     } catch (std::out_of_range& e) {
78417       {
78418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78419       };
78420     } catch (std::exception& e) {
78421       {
78422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78423       };
78424     } catch (...) {
78425       {
78426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78427       };
78428     }
78429   }
78430   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78431   return jresult;
78432 }
78433
78434
78435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78436   void * jresult ;
78437   Dali::BaseHandle arg1 ;
78438   Dali::BaseHandle *argp1 ;
78439   Dali::Toolkit::PageTurnPortraitView result;
78440
78441   argp1 = (Dali::BaseHandle *)jarg1;
78442   if (!argp1) {
78443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78444     return 0;
78445   }
78446   arg1 = *argp1;
78447   {
78448     try {
78449       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78450     } catch (std::out_of_range& e) {
78451       {
78452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78453       };
78454     } catch (std::exception& e) {
78455       {
78456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78457       };
78458     } catch (...) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78461       };
78462     }
78463   }
78464   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78470   int jresult ;
78471   int result;
78472
78473   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78474   jresult = (int)result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78480   int jresult ;
78481   int result;
78482
78483   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78484   jresult = (int)result;
78485   return jresult;
78486 }
78487
78488
78489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78490   int jresult ;
78491   int result;
78492
78493   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78494   jresult = (int)result;
78495   return jresult;
78496 }
78497
78498
78499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78500   void * jresult ;
78501   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78502
78503   {
78504     try {
78505       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78506     } catch (std::out_of_range& e) {
78507       {
78508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78509       };
78510     } catch (std::exception& e) {
78511       {
78512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78513       };
78514     } catch (...) {
78515       {
78516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78517       };
78518     }
78519   }
78520   jresult = (void *)result;
78521   return jresult;
78522 }
78523
78524
78525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78526   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78527
78528   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78529   {
78530     try {
78531       delete arg1;
78532     } catch (std::out_of_range& e) {
78533       {
78534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78535       };
78536     } catch (std::exception& e) {
78537       {
78538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78539       };
78540     } catch (...) {
78541       {
78542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78543       };
78544     }
78545   }
78546 }
78547
78548
78549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78550   void * jresult ;
78551   Dali::Toolkit::ToggleButton *result = 0 ;
78552
78553   {
78554     try {
78555       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78556     } catch (std::out_of_range& e) {
78557       {
78558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78559       };
78560     } catch (std::exception& e) {
78561       {
78562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78563       };
78564     } catch (...) {
78565       {
78566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78567       };
78568     }
78569   }
78570   jresult = (void *)result;
78571   return jresult;
78572 }
78573
78574
78575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78576   void * jresult ;
78577   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78578   Dali::Toolkit::ToggleButton *result = 0 ;
78579
78580   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78581   if (!arg1) {
78582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78583     return 0;
78584   }
78585   {
78586     try {
78587       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78588     } catch (std::out_of_range& e) {
78589       {
78590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78591       };
78592     } catch (std::exception& e) {
78593       {
78594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78595       };
78596     } catch (...) {
78597       {
78598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78599       };
78600     }
78601   }
78602   jresult = (void *)result;
78603   return jresult;
78604 }
78605
78606
78607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78608   void * jresult ;
78609   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78610   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78611   Dali::Toolkit::ToggleButton *result = 0 ;
78612
78613   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78614   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78615   if (!arg2) {
78616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78617     return 0;
78618   }
78619   {
78620     try {
78621       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78622     } catch (std::out_of_range& e) {
78623       {
78624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78625       };
78626     } catch (std::exception& e) {
78627       {
78628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78629       };
78630     } catch (...) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78633       };
78634     }
78635   }
78636   jresult = (void *)result;
78637   return jresult;
78638 }
78639
78640
78641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78642   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78643
78644   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78645   {
78646     try {
78647       delete arg1;
78648     } catch (std::out_of_range& e) {
78649       {
78650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78651       };
78652     } catch (std::exception& e) {
78653       {
78654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78655       };
78656     } catch (...) {
78657       {
78658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78659       };
78660     }
78661   }
78662 }
78663
78664
78665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78666   void * jresult ;
78667   Dali::Toolkit::ToggleButton result;
78668
78669   {
78670     try {
78671       result = Dali::Toolkit::ToggleButton::New();
78672     } catch (std::out_of_range& e) {
78673       {
78674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78675       };
78676     } catch (std::exception& e) {
78677       {
78678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78679       };
78680     } catch (...) {
78681       {
78682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78683       };
78684     }
78685   }
78686   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78687   return jresult;
78688 }
78689
78690
78691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78692   void * jresult ;
78693   Dali::BaseHandle arg1 ;
78694   Dali::BaseHandle *argp1 ;
78695   Dali::Toolkit::ToggleButton result;
78696
78697   argp1 = (Dali::BaseHandle *)jarg1;
78698   if (!argp1) {
78699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78700     return 0;
78701   }
78702   arg1 = *argp1;
78703   {
78704     try {
78705       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78706     } catch (std::out_of_range& e) {
78707       {
78708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78709       };
78710     } catch (std::exception& e) {
78711       {
78712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78713       };
78714     } catch (...) {
78715       {
78716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78717       };
78718     }
78719   }
78720   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78721   return jresult;
78722 }
78723
78724
78725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78726   void * jresult ;
78727   Dali::Toolkit::Visual::Base *result = 0 ;
78728
78729   {
78730     try {
78731       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78732     } catch (std::out_of_range& e) {
78733       {
78734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78735       };
78736     } catch (std::exception& e) {
78737       {
78738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78739       };
78740     } catch (...) {
78741       {
78742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78743       };
78744     }
78745   }
78746   jresult = (void *)result;
78747   return jresult;
78748 }
78749
78750
78751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78752   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78753
78754   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78755   {
78756     try {
78757       delete arg1;
78758     } catch (std::out_of_range& e) {
78759       {
78760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78761       };
78762     } catch (std::exception& e) {
78763       {
78764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78765       };
78766     } catch (...) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78769       };
78770     }
78771   }
78772 }
78773
78774
78775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78776   void * jresult ;
78777   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78778   Dali::Toolkit::Visual::Base *result = 0 ;
78779
78780   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78781   if (!arg1) {
78782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78783     return 0;
78784   }
78785   {
78786     try {
78787       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78788     } catch (std::out_of_range& e) {
78789       {
78790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78791       };
78792     } catch (std::exception& e) {
78793       {
78794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78795       };
78796     } catch (...) {
78797       {
78798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78799       };
78800     }
78801   }
78802   jresult = (void *)result;
78803   return jresult;
78804 }
78805
78806
78807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78808   void * jresult ;
78809   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78810   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78811   Dali::Toolkit::Visual::Base *result = 0 ;
78812
78813   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78814   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78815   if (!arg2) {
78816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78817     return 0;
78818   }
78819   {
78820     try {
78821       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78822     } catch (std::out_of_range& e) {
78823       {
78824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78825       };
78826     } catch (std::exception& e) {
78827       {
78828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78829       };
78830     } catch (...) {
78831       {
78832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78833       };
78834     }
78835   }
78836   jresult = (void *)result;
78837   return jresult;
78838 }
78839
78840
78841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78842   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78843   std::string *arg2 = 0 ;
78844
78845   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78846   if (!jarg2) {
78847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78848     return ;
78849   }
78850   std::string arg2_str(jarg2);
78851   arg2 = &arg2_str;
78852   {
78853     try {
78854       (arg1)->SetName((std::string const &)*arg2);
78855     } catch (std::out_of_range& e) {
78856       {
78857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78858       };
78859     } catch (std::exception& e) {
78860       {
78861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78866       };
78867     }
78868   }
78869
78870   //argout typemap for const std::string&
78871
78872 }
78873
78874
78875 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78876   char * jresult ;
78877   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78878   std::string *result = 0 ;
78879
78880   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78881   {
78882     try {
78883       result = (std::string *) &(arg1)->GetName();
78884     } catch (std::out_of_range& e) {
78885       {
78886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78887       };
78888     } catch (std::exception& e) {
78889       {
78890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78891       };
78892     } catch (...) {
78893       {
78894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78895       };
78896     }
78897   }
78898   jresult = SWIG_csharp_string_callback(result->c_str());
78899   return jresult;
78900 }
78901
78902
78903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78904   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78905   Dali::Property::Map *arg2 = 0 ;
78906   Dali::Size arg3 ;
78907   Dali::Size *argp3 ;
78908
78909   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78910   arg2 = (Dali::Property::Map *)jarg2;
78911   if (!arg2) {
78912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78913     return ;
78914   }
78915   argp3 = (Dali::Size *)jarg3;
78916   if (!argp3) {
78917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78918     return ;
78919   }
78920   arg3 = *argp3;
78921   {
78922     try {
78923       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78924     } catch (std::out_of_range& e) {
78925       {
78926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78927       };
78928     } catch (std::exception& e) {
78929       {
78930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78931       };
78932     } catch (...) {
78933       {
78934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78935       };
78936     }
78937   }
78938 }
78939
78940
78941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78942   float jresult ;
78943   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78944   float arg2 ;
78945   float result;
78946
78947   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78948   arg2 = (float)jarg2;
78949   {
78950     try {
78951       result = (float)(arg1)->GetHeightForWidth(arg2);
78952     } catch (std::out_of_range& e) {
78953       {
78954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78955       };
78956     } catch (std::exception& e) {
78957       {
78958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78959       };
78960     } catch (...) {
78961       {
78962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78963       };
78964     }
78965   }
78966   jresult = result;
78967   return jresult;
78968 }
78969
78970
78971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78972   float jresult ;
78973   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78974   float arg2 ;
78975   float result;
78976
78977   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78978   arg2 = (float)jarg2;
78979   {
78980     try {
78981       result = (float)(arg1)->GetWidthForHeight(arg2);
78982     } catch (std::out_of_range& e) {
78983       {
78984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78985       };
78986     } catch (std::exception& e) {
78987       {
78988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78989       };
78990     } catch (...) {
78991       {
78992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78993       };
78994     }
78995   }
78996   jresult = result;
78997   return jresult;
78998 }
78999
79000
79001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
79002   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79003   Dali::Vector2 *arg2 = 0 ;
79004
79005   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79006   arg2 = (Dali::Vector2 *)jarg2;
79007   if (!arg2) {
79008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
79009     return ;
79010   }
79011   {
79012     try {
79013       (arg1)->GetNaturalSize(*arg2);
79014     } catch (std::out_of_range& e) {
79015       {
79016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79017       };
79018     } catch (std::exception& e) {
79019       {
79020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79021       };
79022     } catch (...) {
79023       {
79024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79025       };
79026     }
79027   }
79028 }
79029
79030
79031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
79032   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79033   float arg2 ;
79034
79035   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79036   arg2 = (int)jarg2;
79037   {
79038     try {
79039       (arg1)->SetDepthIndex(arg2);
79040     } catch (std::out_of_range& e) {
79041       {
79042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79043       };
79044     } catch (std::exception& e) {
79045       {
79046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79047       };
79048     } catch (...) {
79049       {
79050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79051       };
79052     }
79053   }
79054 }
79055
79056
79057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79058   int jresult ;
79059   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79060   int result;
79061
79062   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79063   {
79064     try {
79065       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79066     } catch (std::out_of_range& e) {
79067       {
79068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79069       };
79070     } catch (std::exception& e) {
79071       {
79072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79073       };
79074     } catch (...) {
79075       {
79076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79077       };
79078     }
79079   }
79080   jresult = result;
79081   return jresult;
79082 }
79083
79084
79085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79086   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79087   Dali::Property::Map *arg2 = 0 ;
79088
79089   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79090   arg2 = (Dali::Property::Map *)jarg2;
79091   if (!arg2) {
79092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79093     return ;
79094   }
79095   {
79096     try {
79097       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79098     } catch (std::out_of_range& e) {
79099       {
79100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79101       };
79102     } catch (std::exception& e) {
79103       {
79104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79105       };
79106     } catch (...) {
79107       {
79108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79109       };
79110     }
79111   }
79112 }
79113
79114
79115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79116   void * jresult ;
79117   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79118   Dali::Toolkit::Visual::Base *result = 0 ;
79119
79120   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79121   {
79122     try {
79123       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79124     } catch (std::out_of_range& e) {
79125       {
79126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79127       };
79128     } catch (std::exception& e) {
79129       {
79130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79131       };
79132     } catch (...) {
79133       {
79134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79135       };
79136     }
79137   }
79138   jresult = (void *)result;
79139   return jresult;
79140 }
79141
79142
79143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79144   void * jresult ;
79145   Dali::Toolkit::VisualFactory result;
79146
79147   {
79148     try {
79149       result = Dali::Toolkit::VisualFactory::Get();
79150     } catch (std::out_of_range& e) {
79151       {
79152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79153       };
79154     } catch (std::exception& e) {
79155       {
79156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79157       };
79158     } catch (...) {
79159       {
79160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79161       };
79162     }
79163   }
79164   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79165   return jresult;
79166 }
79167
79168
79169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79170   void * jresult ;
79171   Dali::Toolkit::VisualFactory *result = 0 ;
79172
79173   {
79174     try {
79175       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79176     } catch (std::out_of_range& e) {
79177       {
79178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (std::exception& e) {
79181       {
79182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79183       };
79184     } catch (...) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79187       };
79188     }
79189   }
79190   jresult = (void *)result;
79191   return jresult;
79192 }
79193
79194
79195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79196   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79197
79198   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79199   {
79200     try {
79201       delete arg1;
79202     } catch (std::out_of_range& e) {
79203       {
79204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79205       };
79206     } catch (std::exception& e) {
79207       {
79208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79213       };
79214     }
79215   }
79216 }
79217
79218
79219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79220   void * jresult ;
79221   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79222   Dali::Toolkit::VisualFactory *result = 0 ;
79223
79224   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79225   if (!arg1) {
79226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79227     return 0;
79228   }
79229   {
79230     try {
79231       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79232     } catch (std::out_of_range& e) {
79233       {
79234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79235       };
79236     } catch (std::exception& e) {
79237       {
79238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79239       };
79240     } catch (...) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79243       };
79244     }
79245   }
79246   jresult = (void *)result;
79247   return jresult;
79248 }
79249
79250
79251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79252   void * jresult ;
79253   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79254   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79255   Dali::Toolkit::VisualFactory *result = 0 ;
79256
79257   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79258   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79259   if (!arg2) {
79260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79261     return 0;
79262   }
79263   {
79264     try {
79265       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79266     } catch (std::out_of_range& e) {
79267       {
79268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (std::exception& e) {
79271       {
79272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79273       };
79274     } catch (...) {
79275       {
79276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79277       };
79278     }
79279   }
79280   jresult = (void *)result;
79281   return jresult;
79282 }
79283
79284
79285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79286   void * jresult ;
79287   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79288   Dali::Property::Map *arg2 = 0 ;
79289   Dali::Toolkit::Visual::Base result;
79290
79291   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79292   arg2 = (Dali::Property::Map *)jarg2;
79293   if (!arg2) {
79294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79295     return 0;
79296   }
79297   {
79298     try {
79299       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79300     } catch (std::out_of_range& e) {
79301       {
79302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79303       };
79304     } catch (std::exception& e) {
79305       {
79306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79307       };
79308     } catch (...) {
79309       {
79310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79311       };
79312     }
79313   }
79314   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79315   return jresult;
79316 }
79317
79318
79319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79320   void * jresult ;
79321   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79322   Dali::Image *arg2 = 0 ;
79323   Dali::Toolkit::Visual::Base result;
79324
79325   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79326   arg2 = (Dali::Image *)jarg2;
79327   if (!arg2) {
79328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79329     return 0;
79330   }
79331   {
79332     try {
79333       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79334     } catch (std::out_of_range& e) {
79335       {
79336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79337       };
79338     } catch (std::exception& e) {
79339       {
79340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (...) {
79343       {
79344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79345       };
79346     }
79347   }
79348   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79349   return jresult;
79350 }
79351
79352
79353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79354   void * jresult ;
79355   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79356   std::string *arg2 = 0 ;
79357   Dali::ImageDimensions arg3 ;
79358   Dali::ImageDimensions *argp3 ;
79359   Dali::Toolkit::Visual::Base result;
79360
79361   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79362   if (!jarg2) {
79363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79364     return 0;
79365   }
79366   std::string arg2_str(jarg2);
79367   arg2 = &arg2_str;
79368   argp3 = (Dali::ImageDimensions *)jarg3;
79369   if (!argp3) {
79370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79371     return 0;
79372   }
79373   arg3 = *argp3;
79374   {
79375     try {
79376       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79377     } catch (std::out_of_range& e) {
79378       {
79379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (std::exception& e) {
79382       {
79383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79384       };
79385     } catch (...) {
79386       {
79387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79388       };
79389     }
79390   }
79391   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79392
79393   //argout typemap for const std::string&
79394
79395   return jresult;
79396 }
79397
79398
79399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79400   void * jresult ;
79401   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79402
79403   {
79404     try {
79405       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79406     } catch (std::out_of_range& e) {
79407       {
79408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79409       };
79410     } catch (std::exception& e) {
79411       {
79412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79413       };
79414     } catch (...) {
79415       {
79416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79417       };
79418     }
79419   }
79420   jresult = (void *)result;
79421   return jresult;
79422 }
79423
79424
79425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79426   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79427
79428   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79429   {
79430     try {
79431       delete arg1;
79432     } catch (std::out_of_range& e) {
79433       {
79434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79435       };
79436     } catch (std::exception& e) {
79437       {
79438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79439       };
79440     } catch (...) {
79441       {
79442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79443       };
79444     }
79445   }
79446 }
79447
79448
79449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79450   void * jresult ;
79451   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79452   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79453
79454   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79455   if (!arg1) {
79456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79457     return 0;
79458   }
79459   {
79460     try {
79461       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79462     } catch (std::out_of_range& e) {
79463       {
79464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79465       };
79466     } catch (std::exception& e) {
79467       {
79468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79469       };
79470     } catch (...) {
79471       {
79472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79473       };
79474     }
79475   }
79476   jresult = (void *)result;
79477   return jresult;
79478 }
79479
79480
79481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79482   void * jresult ;
79483   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79484   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79485   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79486
79487   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79488   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79489   if (!arg2) {
79490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79491     return 0;
79492   }
79493   {
79494     try {
79495       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79496     } catch (std::out_of_range& e) {
79497       {
79498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79499       };
79500     } catch (std::exception& e) {
79501       {
79502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79503       };
79504     } catch (...) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79507       };
79508     }
79509   }
79510   jresult = (void *)result;
79511   return jresult;
79512 }
79513
79514
79515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79516   void * jresult ;
79517   Dali::Toolkit::AsyncImageLoader result;
79518
79519   {
79520     try {
79521       result = Dali::Toolkit::AsyncImageLoader::New();
79522     } catch (std::out_of_range& e) {
79523       {
79524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79525       };
79526     } catch (std::exception& e) {
79527       {
79528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79529       };
79530     } catch (...) {
79531       {
79532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79533       };
79534     }
79535   }
79536   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79537   return jresult;
79538 }
79539
79540
79541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79542   void * jresult ;
79543   Dali::BaseHandle arg1 ;
79544   Dali::BaseHandle *argp1 ;
79545   Dali::Toolkit::AsyncImageLoader result;
79546
79547   argp1 = (Dali::BaseHandle *)jarg1;
79548   if (!argp1) {
79549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79550     return 0;
79551   }
79552   arg1 = *argp1;
79553   {
79554     try {
79555       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79556     } catch (std::out_of_range& e) {
79557       {
79558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79559       };
79560     } catch (std::exception& e) {
79561       {
79562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79563       };
79564     } catch (...) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79567       };
79568     }
79569   }
79570   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79571   return jresult;
79572 }
79573
79574
79575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79576   unsigned int jresult ;
79577   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79578   std::string *arg2 = 0 ;
79579   uint32_t result;
79580
79581   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79582   if (!jarg2) {
79583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79584     return 0;
79585   }
79586   std::string arg2_str(jarg2);
79587   arg2 = &arg2_str;
79588   {
79589     try {
79590       result = (arg1)->Load((std::string const &)*arg2);
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (...) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79602       };
79603     }
79604   }
79605   jresult = result;
79606
79607   //argout typemap for const std::string&
79608
79609   return jresult;
79610 }
79611
79612
79613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79614   unsigned int jresult ;
79615   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79616   std::string *arg2 = 0 ;
79617   Dali::ImageDimensions arg3 ;
79618   Dali::ImageDimensions *argp3 ;
79619   uint32_t result;
79620
79621   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79622   if (!jarg2) {
79623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79624     return 0;
79625   }
79626   std::string arg2_str(jarg2);
79627   arg2 = &arg2_str;
79628   argp3 = (Dali::ImageDimensions *)jarg3;
79629   if (!argp3) {
79630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79631     return 0;
79632   }
79633   arg3 = *argp3;
79634   {
79635     try {
79636       result = (arg1)->Load((std::string const &)*arg2,arg3);
79637     } catch (std::out_of_range& e) {
79638       {
79639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (std::exception& e) {
79642       {
79643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (...) {
79646       {
79647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79648       };
79649     }
79650   }
79651   jresult = result;
79652
79653   //argout typemap for const std::string&
79654
79655   return jresult;
79656 }
79657
79658
79659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79660   unsigned int jresult ;
79661   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79662   std::string *arg2 = 0 ;
79663   Dali::ImageDimensions arg3 ;
79664   Dali::FittingMode::Type arg4 ;
79665   Dali::SamplingMode::Type arg5 ;
79666   bool arg6 ;
79667   Dali::ImageDimensions *argp3 ;
79668   uint32_t result;
79669
79670   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79671   if (!jarg2) {
79672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79673     return 0;
79674   }
79675   std::string arg2_str(jarg2);
79676   arg2 = &arg2_str;
79677   argp3 = (Dali::ImageDimensions *)jarg3;
79678   if (!argp3) {
79679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79680     return 0;
79681   }
79682   arg3 = *argp3;
79683   arg4 = (Dali::FittingMode::Type)jarg4;
79684   arg5 = (Dali::SamplingMode::Type)jarg5;
79685   arg6 = jarg6 ? true : false;
79686   {
79687     try {
79688       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79689     } catch (std::out_of_range& e) {
79690       {
79691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79692       };
79693     } catch (std::exception& e) {
79694       {
79695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79696       };
79697     } catch (...) {
79698       {
79699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79700       };
79701     }
79702   }
79703   jresult = result;
79704
79705   //argout typemap for const std::string&
79706
79707   return jresult;
79708 }
79709
79710
79711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79712   unsigned int jresult ;
79713   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79714   uint32_t arg2 ;
79715   bool result;
79716
79717   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79718   arg2 = (uint32_t)jarg2;
79719   {
79720     try {
79721       result = (bool)(arg1)->Cancel(arg2);
79722     } catch (std::out_of_range& e) {
79723       {
79724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79725       };
79726     } catch (std::exception& e) {
79727       {
79728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79729       };
79730     } catch (...) {
79731       {
79732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79733       };
79734     }
79735   }
79736   jresult = result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79742   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79743
79744   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79745   {
79746     try {
79747       (arg1)->CancelAll();
79748     } catch (std::out_of_range& e) {
79749       {
79750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79751       };
79752     } catch (std::exception& e) {
79753       {
79754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79755       };
79756     } catch (...) {
79757       {
79758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79759       };
79760     }
79761   }
79762 }
79763
79764
79765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79766   void * jresult ;
79767   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79768   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79769
79770   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79771   {
79772     try {
79773       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79774     } catch (std::out_of_range& e) {
79775       {
79776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (std::exception& e) {
79779       {
79780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (...) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79785       };
79786     }
79787   }
79788   jresult = (void *)result;
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79794   void * jresult ;
79795   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79796   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79797
79798   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79799   {
79800     try {
79801       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79802     } catch (std::out_of_range& e) {
79803       {
79804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79805       };
79806     } catch (std::exception& e) {
79807       {
79808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79809       };
79810     } catch (...) {
79811       {
79812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79813       };
79814     }
79815   }
79816   jresult = (void *)result;
79817   return jresult;
79818 }
79819
79820
79821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79822   void * jresult ;
79823   std::string *arg1 = 0 ;
79824   Dali::PixelData result;
79825
79826   if (!jarg1) {
79827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79828     return 0;
79829   }
79830   std::string arg1_str(jarg1);
79831   arg1 = &arg1_str;
79832   {
79833     try {
79834       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79835     } catch (std::out_of_range& e) {
79836       {
79837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79838       };
79839     } catch (std::exception& e) {
79840       {
79841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79842       };
79843     } catch (...) {
79844       {
79845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79846       };
79847     }
79848   }
79849   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79850
79851   //argout typemap for const std::string&
79852
79853   return jresult;
79854 }
79855
79856
79857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79858   void * jresult ;
79859   std::string *arg1 = 0 ;
79860   Dali::ImageDimensions arg2 ;
79861   Dali::ImageDimensions *argp2 ;
79862   Dali::PixelData result;
79863
79864   if (!jarg1) {
79865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79866     return 0;
79867   }
79868   std::string arg1_str(jarg1);
79869   arg1 = &arg1_str;
79870   argp2 = (Dali::ImageDimensions *)jarg2;
79871   if (!argp2) {
79872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79873     return 0;
79874   }
79875   arg2 = *argp2;
79876   {
79877     try {
79878       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79879     } catch (std::out_of_range& e) {
79880       {
79881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79882       };
79883     } catch (std::exception& e) {
79884       {
79885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79886       };
79887     } catch (...) {
79888       {
79889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79890       };
79891     }
79892   }
79893   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79894
79895   //argout typemap for const std::string&
79896
79897   return jresult;
79898 }
79899
79900
79901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79902   void * jresult ;
79903   std::string *arg1 = 0 ;
79904   Dali::ImageDimensions arg2 ;
79905   Dali::FittingMode::Type arg3 ;
79906   Dali::SamplingMode::Type arg4 ;
79907   bool arg5 ;
79908   Dali::ImageDimensions *argp2 ;
79909   Dali::PixelData result;
79910
79911   if (!jarg1) {
79912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79913     return 0;
79914   }
79915   std::string arg1_str(jarg1);
79916   arg1 = &arg1_str;
79917   argp2 = (Dali::ImageDimensions *)jarg2;
79918   if (!argp2) {
79919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79920     return 0;
79921   }
79922   arg2 = *argp2;
79923   arg3 = (Dali::FittingMode::Type)jarg3;
79924   arg4 = (Dali::SamplingMode::Type)jarg4;
79925   arg5 = jarg5 ? true : false;
79926   {
79927     try {
79928       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79929     } catch (std::out_of_range& e) {
79930       {
79931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79932       };
79933     } catch (std::exception& e) {
79934       {
79935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79936       };
79937     } catch (...) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79940       };
79941     }
79942   }
79943   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79944
79945   //argout typemap for const std::string&
79946
79947   return jresult;
79948 }
79949
79950
79951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79952   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79953
79954   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79955   {
79956     try {
79957       delete arg1;
79958     } catch (std::out_of_range& e) {
79959       {
79960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79961       };
79962     } catch (std::exception& e) {
79963       {
79964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79965       };
79966     } catch (...) {
79967       {
79968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79969       };
79970     }
79971   }
79972 }
79973
79974
79975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79976   void * jresult ;
79977   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79978   Dali::Actor arg2 ;
79979   Dali::Actor arg3 ;
79980   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79981   Dali::Actor *argp2 ;
79982   Dali::Actor *argp3 ;
79983   Dali::Actor result;
79984
79985   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79986   argp2 = (Dali::Actor *)jarg2;
79987   if (!argp2) {
79988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79989     return 0;
79990   }
79991   arg2 = *argp2;
79992   argp3 = (Dali::Actor *)jarg3;
79993   if (!argp3) {
79994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79995     return 0;
79996   }
79997   arg3 = *argp3;
79998   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79999   {
80000     try {
80001       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
80002     } catch (std::out_of_range& e) {
80003       {
80004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (std::exception& e) {
80007       {
80008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80009       };
80010     } catch (...) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80013       };
80014     }
80015   }
80016   jresult = new Dali::Actor((const Dali::Actor &)result);
80017   return jresult;
80018 }
80019
80020
80021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
80022   void * jresult ;
80023   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
80024
80025   {
80026     try {
80027       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
80028     } catch (std::out_of_range& e) {
80029       {
80030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80031       };
80032     } catch (std::exception& e) {
80033       {
80034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80035       };
80036     } catch (...) {
80037       {
80038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80039       };
80040     }
80041   }
80042   jresult = (void *)result;
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80048   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80049   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80050   if (director) {
80051     director->swig_connect_director(callback0);
80052   }
80053 }
80054
80055
80056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80057   KeyboardFocusManager arg1 ;
80058   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80059   KeyboardFocusManager *argp1 ;
80060
80061   argp1 = (KeyboardFocusManager *)jarg1;
80062   if (!argp1) {
80063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80064     return ;
80065   }
80066   arg1 = *argp1;
80067   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80068   if (!arg2) {
80069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80070     return ;
80071   }
80072   {
80073     try {
80074       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80075     } catch (std::out_of_range& e) {
80076       {
80077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80078       };
80079     } catch (std::exception& e) {
80080       {
80081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80082       };
80083     } catch (...) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80086       };
80087     }
80088   }
80089 }
80090
80091
80092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80093   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80094
80095   arg1 = (std::vector< unsigned int > *)jarg1;
80096   {
80097     try {
80098       (arg1)->clear();
80099     } catch (std::out_of_range& e) {
80100       {
80101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80102       };
80103     } catch (std::exception& e) {
80104       {
80105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80106       };
80107     } catch (...) {
80108       {
80109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80110       };
80111     }
80112   }
80113 }
80114
80115
80116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80117   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80118   unsigned int *arg2 = 0 ;
80119   unsigned int temp2 ;
80120
80121   arg1 = (std::vector< unsigned int > *)jarg1;
80122   temp2 = (unsigned int)jarg2;
80123   arg2 = &temp2;
80124   {
80125     try {
80126       (arg1)->push_back((unsigned int const &)*arg2);
80127     } catch (std::out_of_range& e) {
80128       {
80129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80130       };
80131     } catch (std::exception& e) {
80132       {
80133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (...) {
80136       {
80137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80138       };
80139     }
80140   }
80141 }
80142
80143
80144 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80145   unsigned long jresult ;
80146   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80147   std::vector< unsigned int >::size_type result;
80148
80149   arg1 = (std::vector< unsigned int > *)jarg1;
80150   {
80151     try {
80152       result = ((std::vector< unsigned int > const *)arg1)->size();
80153     } catch (std::out_of_range& e) {
80154       {
80155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80156       };
80157     } catch (std::exception& e) {
80158       {
80159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80160       };
80161     } catch (...) {
80162       {
80163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80164       };
80165     }
80166   }
80167   jresult = (unsigned long)result;
80168   return jresult;
80169 }
80170
80171
80172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80173   unsigned long jresult ;
80174   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80175   std::vector< unsigned int >::size_type result;
80176
80177   arg1 = (std::vector< unsigned int > *)jarg1;
80178   {
80179     try {
80180       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80181     } catch (std::out_of_range& e) {
80182       {
80183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (std::exception& e) {
80186       {
80187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80188       };
80189     } catch (...) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80192       };
80193     }
80194   }
80195   jresult = (unsigned long)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80201   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80202   std::vector< unsigned int >::size_type arg2 ;
80203
80204   arg1 = (std::vector< unsigned int > *)jarg1;
80205   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80206   {
80207     try {
80208       (arg1)->reserve(arg2);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80220       };
80221     }
80222   }
80223 }
80224
80225
80226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80227   void * jresult ;
80228   std::vector< unsigned int > *result = 0 ;
80229
80230   {
80231     try {
80232       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80233     } catch (std::out_of_range& e) {
80234       {
80235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (std::exception& e) {
80238       {
80239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80240       };
80241     } catch (...) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80244       };
80245     }
80246   }
80247   jresult = (void *)result;
80248   return jresult;
80249 }
80250
80251
80252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80253   void * jresult ;
80254   std::vector< unsigned int > *arg1 = 0 ;
80255   std::vector< unsigned int > *result = 0 ;
80256
80257   arg1 = (std::vector< unsigned int > *)jarg1;
80258   if (!arg1) {
80259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80260     return 0;
80261   }
80262   {
80263     try {
80264       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80265     } catch (std::out_of_range& e) {
80266       {
80267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80268       };
80269     } catch (std::exception& e) {
80270       {
80271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (...) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80276       };
80277     }
80278   }
80279   jresult = (void *)result;
80280   return jresult;
80281 }
80282
80283
80284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80285   void * jresult ;
80286   int arg1 ;
80287   std::vector< unsigned int > *result = 0 ;
80288
80289   arg1 = (int)jarg1;
80290   {
80291     try {
80292       try {
80293         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80294       }
80295       catch(std::out_of_range &_e) {
80296         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80297         return 0;
80298       }
80299
80300     } catch (std::out_of_range& e) {
80301       {
80302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80303       };
80304     } catch (std::exception& e) {
80305       {
80306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80307       };
80308     } catch (...) {
80309       {
80310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80311       };
80312     }
80313   }
80314   jresult = (void *)result;
80315   return jresult;
80316 }
80317
80318
80319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80320   unsigned int jresult ;
80321   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80322   int arg2 ;
80323   unsigned int result;
80324
80325   arg1 = (std::vector< unsigned int > *)jarg1;
80326   arg2 = (int)jarg2;
80327   {
80328     try {
80329       try {
80330         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80331       }
80332       catch(std::out_of_range &_e) {
80333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80334         return 0;
80335       }
80336
80337     } catch (std::out_of_range& e) {
80338       {
80339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80340       };
80341     } catch (std::exception& e) {
80342       {
80343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (...) {
80346       {
80347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80348       };
80349     }
80350   }
80351   jresult = result;
80352   return jresult;
80353 }
80354
80355
80356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80357   unsigned int jresult ;
80358   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80359   int arg2 ;
80360   unsigned int *result = 0 ;
80361
80362   arg1 = (std::vector< unsigned int > *)jarg1;
80363   arg2 = (int)jarg2;
80364   {
80365     try {
80366       try {
80367         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80368       }
80369       catch(std::out_of_range &_e) {
80370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80371         return 0;
80372       }
80373
80374     } catch (std::out_of_range& e) {
80375       {
80376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80377       };
80378     } catch (std::exception& e) {
80379       {
80380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80381       };
80382     } catch (...) {
80383       {
80384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80385       };
80386     }
80387   }
80388   jresult = *result;
80389   return jresult;
80390 }
80391
80392
80393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80394   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80395   int arg2 ;
80396   unsigned int *arg3 = 0 ;
80397   unsigned int temp3 ;
80398
80399   arg1 = (std::vector< unsigned int > *)jarg1;
80400   arg2 = (int)jarg2;
80401   temp3 = (unsigned int)jarg3;
80402   arg3 = &temp3;
80403   {
80404     try {
80405       try {
80406         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80407       }
80408       catch(std::out_of_range &_e) {
80409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80410         return ;
80411       }
80412
80413     } catch (std::out_of_range& e) {
80414       {
80415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80416       };
80417     } catch (std::exception& e) {
80418       {
80419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80420       };
80421     } catch (...) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80424       };
80425     }
80426   }
80427 }
80428
80429
80430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80431   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80432   std::vector< unsigned int > *arg2 = 0 ;
80433
80434   arg1 = (std::vector< unsigned int > *)jarg1;
80435   arg2 = (std::vector< unsigned int > *)jarg2;
80436   if (!arg2) {
80437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80438     return ;
80439   }
80440   {
80441     try {
80442       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80443     } catch (std::out_of_range& e) {
80444       {
80445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80446       };
80447     } catch (std::exception& e) {
80448       {
80449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80450       };
80451     } catch (...) {
80452       {
80453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80454       };
80455     }
80456   }
80457 }
80458
80459
80460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80461   void * jresult ;
80462   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80463   int arg2 ;
80464   int arg3 ;
80465   std::vector< unsigned int > *result = 0 ;
80466
80467   arg1 = (std::vector< unsigned int > *)jarg1;
80468   arg2 = (int)jarg2;
80469   arg3 = (int)jarg3;
80470   {
80471     try {
80472       try {
80473         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80474       }
80475       catch(std::out_of_range &_e) {
80476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80477         return 0;
80478       }
80479       catch(std::invalid_argument &_e) {
80480         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80481         return 0;
80482       }
80483
80484     } catch (std::out_of_range& e) {
80485       {
80486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80487       };
80488     } catch (std::exception& e) {
80489       {
80490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80491       };
80492     } catch (...) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80495       };
80496     }
80497   }
80498   jresult = (void *)result;
80499   return jresult;
80500 }
80501
80502
80503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80504   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80505   int arg2 ;
80506   unsigned int *arg3 = 0 ;
80507   unsigned int temp3 ;
80508
80509   arg1 = (std::vector< unsigned int > *)jarg1;
80510   arg2 = (int)jarg2;
80511   temp3 = (unsigned int)jarg3;
80512   arg3 = &temp3;
80513   {
80514     try {
80515       try {
80516         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80517       }
80518       catch(std::out_of_range &_e) {
80519         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80520         return ;
80521       }
80522
80523     } catch (std::out_of_range& e) {
80524       {
80525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (std::exception& e) {
80528       {
80529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80530       };
80531     } catch (...) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80534       };
80535     }
80536   }
80537 }
80538
80539
80540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80541   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80542   int arg2 ;
80543   std::vector< unsigned int > *arg3 = 0 ;
80544
80545   arg1 = (std::vector< unsigned int > *)jarg1;
80546   arg2 = (int)jarg2;
80547   arg3 = (std::vector< unsigned int > *)jarg3;
80548   if (!arg3) {
80549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80550     return ;
80551   }
80552   {
80553     try {
80554       try {
80555         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80556       }
80557       catch(std::out_of_range &_e) {
80558         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80559         return ;
80560       }
80561
80562     } catch (std::out_of_range& e) {
80563       {
80564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80565       };
80566     } catch (std::exception& e) {
80567       {
80568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80569       };
80570     } catch (...) {
80571       {
80572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80573       };
80574     }
80575   }
80576 }
80577
80578
80579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80580   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80581   int arg2 ;
80582
80583   arg1 = (std::vector< unsigned int > *)jarg1;
80584   arg2 = (int)jarg2;
80585   {
80586     try {
80587       try {
80588         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80589       }
80590       catch(std::out_of_range &_e) {
80591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80592         return ;
80593       }
80594
80595     } catch (std::out_of_range& e) {
80596       {
80597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80598       };
80599     } catch (std::exception& e) {
80600       {
80601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80602       };
80603     } catch (...) {
80604       {
80605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80606       };
80607     }
80608   }
80609 }
80610
80611
80612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80613   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80614   int arg2 ;
80615   int arg3 ;
80616
80617   arg1 = (std::vector< unsigned int > *)jarg1;
80618   arg2 = (int)jarg2;
80619   arg3 = (int)jarg3;
80620   {
80621     try {
80622       try {
80623         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80624       }
80625       catch(std::out_of_range &_e) {
80626         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80627         return ;
80628       }
80629       catch(std::invalid_argument &_e) {
80630         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80631         return ;
80632       }
80633
80634     } catch (std::out_of_range& e) {
80635       {
80636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80637       };
80638     } catch (std::exception& e) {
80639       {
80640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80641       };
80642     } catch (...) {
80643       {
80644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80645       };
80646     }
80647   }
80648 }
80649
80650
80651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80652   void * jresult ;
80653   unsigned int *arg1 = 0 ;
80654   int arg2 ;
80655   unsigned int temp1 ;
80656   std::vector< unsigned int > *result = 0 ;
80657
80658   temp1 = (unsigned int)jarg1;
80659   arg1 = &temp1;
80660   arg2 = (int)jarg2;
80661   {
80662     try {
80663       try {
80664         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80665       }
80666       catch(std::out_of_range &_e) {
80667         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80668         return 0;
80669       }
80670
80671     } catch (std::out_of_range& e) {
80672       {
80673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80674       };
80675     } catch (std::exception& e) {
80676       {
80677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80678       };
80679     } catch (...) {
80680       {
80681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80682       };
80683     }
80684   }
80685   jresult = (void *)result;
80686   return jresult;
80687 }
80688
80689
80690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80691   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80692
80693   arg1 = (std::vector< unsigned int > *)jarg1;
80694   {
80695     try {
80696       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80697     } catch (std::out_of_range& e) {
80698       {
80699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80700       };
80701     } catch (std::exception& e) {
80702       {
80703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80704       };
80705     } catch (...) {
80706       {
80707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80708       };
80709     }
80710   }
80711 }
80712
80713
80714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80715   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80716   int arg2 ;
80717   int arg3 ;
80718
80719   arg1 = (std::vector< unsigned int > *)jarg1;
80720   arg2 = (int)jarg2;
80721   arg3 = (int)jarg3;
80722   {
80723     try {
80724       try {
80725         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80726       }
80727       catch(std::out_of_range &_e) {
80728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80729         return ;
80730       }
80731       catch(std::invalid_argument &_e) {
80732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80733         return ;
80734       }
80735
80736     } catch (std::out_of_range& e) {
80737       {
80738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80739       };
80740     } catch (std::exception& e) {
80741       {
80742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80743       };
80744     } catch (...) {
80745       {
80746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80747       };
80748     }
80749   }
80750 }
80751
80752
80753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80754   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80755   int arg2 ;
80756   std::vector< unsigned int > *arg3 = 0 ;
80757
80758   arg1 = (std::vector< unsigned int > *)jarg1;
80759   arg2 = (int)jarg2;
80760   arg3 = (std::vector< unsigned int > *)jarg3;
80761   if (!arg3) {
80762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80763     return ;
80764   }
80765   {
80766     try {
80767       try {
80768         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80769       }
80770       catch(std::out_of_range &_e) {
80771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80772         return ;
80773       }
80774
80775     } catch (std::out_of_range& e) {
80776       {
80777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80778       };
80779     } catch (std::exception& e) {
80780       {
80781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80782       };
80783     } catch (...) {
80784       {
80785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80786       };
80787     }
80788   }
80789 }
80790
80791
80792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80793   unsigned int jresult ;
80794   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80795   unsigned int *arg2 = 0 ;
80796   unsigned int temp2 ;
80797   bool result;
80798
80799   arg1 = (std::vector< unsigned int > *)jarg1;
80800   temp2 = (unsigned int)jarg2;
80801   arg2 = &temp2;
80802   {
80803     try {
80804       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (...) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80816       };
80817     }
80818   }
80819   jresult = result;
80820   return jresult;
80821 }
80822
80823
80824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80825   int jresult ;
80826   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80827   unsigned int *arg2 = 0 ;
80828   unsigned int temp2 ;
80829   int result;
80830
80831   arg1 = (std::vector< unsigned int > *)jarg1;
80832   temp2 = (unsigned int)jarg2;
80833   arg2 = &temp2;
80834   {
80835     try {
80836       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80837     } catch (std::out_of_range& e) {
80838       {
80839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (std::exception& e) {
80842       {
80843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80848       };
80849     }
80850   }
80851   jresult = result;
80852   return jresult;
80853 }
80854
80855
80856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80857   int jresult ;
80858   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80859   unsigned int *arg2 = 0 ;
80860   unsigned int temp2 ;
80861   int result;
80862
80863   arg1 = (std::vector< unsigned int > *)jarg1;
80864   temp2 = (unsigned int)jarg2;
80865   arg2 = &temp2;
80866   {
80867     try {
80868       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80876       };
80877     } catch (...) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80880       };
80881     }
80882   }
80883   jresult = result;
80884   return jresult;
80885 }
80886
80887
80888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80889   unsigned int jresult ;
80890   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80891   unsigned int *arg2 = 0 ;
80892   unsigned int temp2 ;
80893   bool result;
80894
80895   arg1 = (std::vector< unsigned int > *)jarg1;
80896   temp2 = (unsigned int)jarg2;
80897   arg2 = &temp2;
80898   {
80899     try {
80900       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80901     } catch (std::out_of_range& e) {
80902       {
80903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80904       };
80905     } catch (std::exception& e) {
80906       {
80907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80908       };
80909     } catch (...) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80912       };
80913     }
80914   }
80915   jresult = result;
80916   return jresult;
80917 }
80918
80919
80920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80921   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80922
80923   arg1 = (std::vector< unsigned int > *)jarg1;
80924   {
80925     try {
80926       delete arg1;
80927     } catch (std::out_of_range& e) {
80928       {
80929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80930       };
80931     } catch (std::exception& e) {
80932       {
80933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80934       };
80935     } catch (...) {
80936       {
80937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80938       };
80939     }
80940   }
80941 }
80942
80943
80944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80945   void * jresult ;
80946   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80947
80948   {
80949     try {
80950       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80951     } catch (std::out_of_range& e) {
80952       {
80953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80954       };
80955     } catch (std::exception& e) {
80956       {
80957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80958       };
80959     } catch (...) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80962       };
80963     }
80964   }
80965   jresult = (void *)result;
80966   return jresult;
80967 }
80968
80969
80970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80971   void * jresult ;
80972   unsigned int arg1 ;
80973   Dali::Actor arg2 ;
80974   Dali::Actor *argp2 ;
80975   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80976
80977   arg1 = (unsigned int)jarg1;
80978   argp2 = (Dali::Actor *)jarg2;
80979   if (!argp2) {
80980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80981     return 0;
80982   }
80983   arg2 = *argp2;
80984   {
80985     try {
80986       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80987     } catch (std::out_of_range& e) {
80988       {
80989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80990       };
80991     } catch (std::exception& e) {
80992       {
80993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80994       };
80995     } catch (...) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80998       };
80999     }
81000   }
81001   jresult = (void *)result;
81002   return jresult;
81003 }
81004
81005
81006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
81007   void * jresult ;
81008   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81009   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81010
81011   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81012   if (!arg1) {
81013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81014     return 0;
81015   }
81016   {
81017     try {
81018       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
81019     } catch (std::out_of_range& e) {
81020       {
81021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81022       };
81023     } catch (std::exception& e) {
81024       {
81025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81026       };
81027     } catch (...) {
81028       {
81029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81030       };
81031     }
81032   }
81033   jresult = (void *)result;
81034   return jresult;
81035 }
81036
81037
81038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81039   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81040   unsigned int arg2 ;
81041
81042   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81043   arg2 = (unsigned int)jarg2;
81044   if (arg1) (arg1)->first = arg2;
81045 }
81046
81047
81048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81049   unsigned int jresult ;
81050   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81051   unsigned int result;
81052
81053   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81054   result = (unsigned int) ((arg1)->first);
81055   jresult = result;
81056   return jresult;
81057 }
81058
81059
81060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81061   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81062   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81063
81064   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81065   arg2 = (Dali::Actor *)jarg2;
81066   if (arg1) (arg1)->second = *arg2;
81067 }
81068
81069
81070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81071   void * jresult ;
81072   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81073   Dali::Actor *result = 0 ;
81074
81075   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81076   result = (Dali::Actor *)& ((arg1)->second);
81077   jresult = (void *)result;
81078   return jresult;
81079 }
81080
81081
81082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81083   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81084
81085   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81086   {
81087     try {
81088       delete arg1;
81089     } catch (std::out_of_range& e) {
81090       {
81091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81092       };
81093     } catch (std::exception& e) {
81094       {
81095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81096       };
81097     } catch (...) {
81098       {
81099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81100       };
81101     }
81102   }
81103 }
81104
81105
81106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81107   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81108
81109   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81110   {
81111     try {
81112       (arg1)->clear();
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81120       };
81121     } catch (...) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81124       };
81125     }
81126   }
81127 }
81128
81129
81130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81131   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81132   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81133
81134   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81135   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81136   if (!arg2) {
81137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81138     return ;
81139   }
81140   {
81141     try {
81142       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81143     } catch (std::out_of_range& e) {
81144       {
81145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81146       };
81147     } catch (std::exception& e) {
81148       {
81149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81150       };
81151     } catch (...) {
81152       {
81153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81154       };
81155     }
81156   }
81157 }
81158
81159
81160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81161   unsigned long jresult ;
81162   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81163   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81164
81165   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81166   {
81167     try {
81168       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81169     } catch (std::out_of_range& e) {
81170       {
81171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81172       };
81173     } catch (std::exception& e) {
81174       {
81175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81176       };
81177     } catch (...) {
81178       {
81179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81180       };
81181     }
81182   }
81183   jresult = (unsigned long)result;
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81189   unsigned long jresult ;
81190   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81191   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81192
81193   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81194   {
81195     try {
81196       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81197     } catch (std::out_of_range& e) {
81198       {
81199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81200       };
81201     } catch (std::exception& e) {
81202       {
81203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81204       };
81205     } catch (...) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81208       };
81209     }
81210   }
81211   jresult = (unsigned long)result;
81212   return jresult;
81213 }
81214
81215
81216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81217   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81218   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81219
81220   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81221   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81222   {
81223     try {
81224       (arg1)->reserve(arg2);
81225     } catch (std::out_of_range& e) {
81226       {
81227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81228       };
81229     } catch (std::exception& e) {
81230       {
81231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81232       };
81233     } catch (...) {
81234       {
81235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81236       };
81237     }
81238   }
81239 }
81240
81241
81242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81243   void * jresult ;
81244   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81245
81246   {
81247     try {
81248       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81249     } catch (std::out_of_range& e) {
81250       {
81251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (std::exception& e) {
81254       {
81255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (...) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81260       };
81261     }
81262   }
81263   jresult = (void *)result;
81264   return jresult;
81265 }
81266
81267
81268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81269   void * jresult ;
81270   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81271   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81272
81273   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81274   if (!arg1) {
81275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81276     return 0;
81277   }
81278   {
81279     try {
81280       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);
81281     } catch (std::out_of_range& e) {
81282       {
81283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81284       };
81285     } catch (std::exception& e) {
81286       {
81287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81288       };
81289     } catch (...) {
81290       {
81291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81292       };
81293     }
81294   }
81295   jresult = (void *)result;
81296   return jresult;
81297 }
81298
81299
81300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81301   void * jresult ;
81302   int arg1 ;
81303   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81304
81305   arg1 = (int)jarg1;
81306   {
81307     try {
81308       try {
81309         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);
81310       }
81311       catch(std::out_of_range &_e) {
81312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81313         return 0;
81314       }
81315
81316     } catch (std::out_of_range& e) {
81317       {
81318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81319       };
81320     } catch (std::exception& e) {
81321       {
81322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81323       };
81324     } catch (...) {
81325       {
81326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81327       };
81328     }
81329   }
81330   jresult = (void *)result;
81331   return jresult;
81332 }
81333
81334
81335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81336   void * jresult ;
81337   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81338   int arg2 ;
81339   std::pair< unsigned int,Dali::Actor > result;
81340
81341   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81342   arg2 = (int)jarg2;
81343   {
81344     try {
81345       try {
81346         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81347       }
81348       catch(std::out_of_range &_e) {
81349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81350         return 0;
81351       }
81352
81353     } catch (std::out_of_range& e) {
81354       {
81355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81356       };
81357     } catch (std::exception& e) {
81358       {
81359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81360       };
81361     } catch (...) {
81362       {
81363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81364       };
81365     }
81366   }
81367   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81368   return jresult;
81369 }
81370
81371
81372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81373   void * jresult ;
81374   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81375   int arg2 ;
81376   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81377
81378   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81379   arg2 = (int)jarg2;
81380   {
81381     try {
81382       try {
81383         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81384       }
81385       catch(std::out_of_range &_e) {
81386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81387         return 0;
81388       }
81389
81390     } catch (std::out_of_range& e) {
81391       {
81392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (std::exception& e) {
81395       {
81396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81397       };
81398     } catch (...) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81401       };
81402     }
81403   }
81404   jresult = (void *)result;
81405   return jresult;
81406 }
81407
81408
81409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81410   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81411   int arg2 ;
81412   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81413
81414   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81415   arg2 = (int)jarg2;
81416   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81417   if (!arg3) {
81418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81419     return ;
81420   }
81421   {
81422     try {
81423       try {
81424         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);
81425       }
81426       catch(std::out_of_range &_e) {
81427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81428         return ;
81429       }
81430
81431     } catch (std::out_of_range& e) {
81432       {
81433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81434       };
81435     } catch (std::exception& e) {
81436       {
81437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81438       };
81439     } catch (...) {
81440       {
81441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81442       };
81443     }
81444   }
81445 }
81446
81447
81448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81449   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81450   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81451
81452   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81453   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81454   if (!arg2) {
81455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81456     return ;
81457   }
81458   {
81459     try {
81460       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);
81461     } catch (std::out_of_range& e) {
81462       {
81463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81464       };
81465     } catch (std::exception& e) {
81466       {
81467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81468       };
81469     } catch (...) {
81470       {
81471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81472       };
81473     }
81474   }
81475 }
81476
81477
81478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81479   void * jresult ;
81480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81481   int arg2 ;
81482   int arg3 ;
81483   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81484
81485   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81486   arg2 = (int)jarg2;
81487   arg3 = (int)jarg3;
81488   {
81489     try {
81490       try {
81491         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);
81492       }
81493       catch(std::out_of_range &_e) {
81494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81495         return 0;
81496       }
81497       catch(std::invalid_argument &_e) {
81498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81499         return 0;
81500       }
81501
81502     } catch (std::out_of_range& e) {
81503       {
81504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81505       };
81506     } catch (std::exception& e) {
81507       {
81508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81509       };
81510     } catch (...) {
81511       {
81512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81513       };
81514     }
81515   }
81516   jresult = (void *)result;
81517   return jresult;
81518 }
81519
81520
81521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81522   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81523   int arg2 ;
81524   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81525
81526   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81527   arg2 = (int)jarg2;
81528   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81529   if (!arg3) {
81530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81531     return ;
81532   }
81533   {
81534     try {
81535       try {
81536         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);
81537       }
81538       catch(std::out_of_range &_e) {
81539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81540         return ;
81541       }
81542
81543     } catch (std::out_of_range& e) {
81544       {
81545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81546       };
81547     } catch (std::exception& e) {
81548       {
81549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81550       };
81551     } catch (...) {
81552       {
81553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81554       };
81555     }
81556   }
81557 }
81558
81559
81560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81561   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81562   int arg2 ;
81563   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81564
81565   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81566   arg2 = (int)jarg2;
81567   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81568   if (!arg3) {
81569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81570     return ;
81571   }
81572   {
81573     try {
81574       try {
81575         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);
81576       }
81577       catch(std::out_of_range &_e) {
81578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81579         return ;
81580       }
81581
81582     } catch (std::out_of_range& e) {
81583       {
81584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81585       };
81586     } catch (std::exception& e) {
81587       {
81588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81589       };
81590     } catch (...) {
81591       {
81592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81593       };
81594     }
81595   }
81596 }
81597
81598
81599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81600   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81601   int arg2 ;
81602
81603   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81604   arg2 = (int)jarg2;
81605   {
81606     try {
81607       try {
81608         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81609       }
81610       catch(std::out_of_range &_e) {
81611         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81612         return ;
81613       }
81614
81615     } catch (std::out_of_range& e) {
81616       {
81617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81618       };
81619     } catch (std::exception& e) {
81620       {
81621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81622       };
81623     } catch (...) {
81624       {
81625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81626       };
81627     }
81628   }
81629 }
81630
81631
81632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81633   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81634   int arg2 ;
81635   int arg3 ;
81636
81637   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81638   arg2 = (int)jarg2;
81639   arg3 = (int)jarg3;
81640   {
81641     try {
81642       try {
81643         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81644       }
81645       catch(std::out_of_range &_e) {
81646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81647         return ;
81648       }
81649       catch(std::invalid_argument &_e) {
81650         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81651         return ;
81652       }
81653
81654     } catch (std::out_of_range& e) {
81655       {
81656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81657       };
81658     } catch (std::exception& e) {
81659       {
81660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81661       };
81662     } catch (...) {
81663       {
81664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81665       };
81666     }
81667   }
81668 }
81669
81670
81671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81672   void * jresult ;
81673   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81674   int arg2 ;
81675   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81676
81677   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81678   if (!arg1) {
81679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81680     return 0;
81681   }
81682   arg2 = (int)jarg2;
81683   {
81684     try {
81685       try {
81686         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);
81687       }
81688       catch(std::out_of_range &_e) {
81689         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81690         return 0;
81691       }
81692
81693     } catch (std::out_of_range& e) {
81694       {
81695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81696       };
81697     } catch (std::exception& e) {
81698       {
81699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (...) {
81702       {
81703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81704       };
81705     }
81706   }
81707   jresult = (void *)result;
81708   return jresult;
81709 }
81710
81711
81712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81713   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81714
81715   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81716   {
81717     try {
81718       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81719     } catch (std::out_of_range& e) {
81720       {
81721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81722       };
81723     } catch (std::exception& e) {
81724       {
81725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (...) {
81728       {
81729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81730       };
81731     }
81732   }
81733 }
81734
81735
81736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81737   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81738   int arg2 ;
81739   int arg3 ;
81740
81741   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81742   arg2 = (int)jarg2;
81743   arg3 = (int)jarg3;
81744   {
81745     try {
81746       try {
81747         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81748       }
81749       catch(std::out_of_range &_e) {
81750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81751         return ;
81752       }
81753       catch(std::invalid_argument &_e) {
81754         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81755         return ;
81756       }
81757
81758     } catch (std::out_of_range& e) {
81759       {
81760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81761       };
81762     } catch (std::exception& e) {
81763       {
81764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81765       };
81766     } catch (...) {
81767       {
81768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81769       };
81770     }
81771   }
81772 }
81773
81774
81775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81776   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81777   int arg2 ;
81778   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81779
81780   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81781   arg2 = (int)jarg2;
81782   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81783   if (!arg3) {
81784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81785     return ;
81786   }
81787   {
81788     try {
81789       try {
81790         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);
81791       }
81792       catch(std::out_of_range &_e) {
81793         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81794         return ;
81795       }
81796
81797     } catch (std::out_of_range& e) {
81798       {
81799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81800       };
81801     } catch (std::exception& e) {
81802       {
81803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (...) {
81806       {
81807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81808       };
81809     }
81810   }
81811 }
81812
81813
81814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81815   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81816
81817   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81818   {
81819     try {
81820       delete arg1;
81821     } catch (std::out_of_range& e) {
81822       {
81823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81824       };
81825     } catch (std::exception& e) {
81826       {
81827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81828       };
81829     } catch (...) {
81830       {
81831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81832       };
81833     }
81834   }
81835 }
81836
81837
81838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81839   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81840
81841   arg1 = (std::vector< Dali::Actor > *)jarg1;
81842   {
81843     try {
81844       (arg1)->clear();
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (...) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81856       };
81857     }
81858   }
81859 }
81860
81861
81862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81863   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81864   Dali::Actor *arg2 = 0 ;
81865
81866   arg1 = (std::vector< Dali::Actor > *)jarg1;
81867   arg2 = (Dali::Actor *)jarg2;
81868   if (!arg2) {
81869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81870     return ;
81871   }
81872   {
81873     try {
81874       (arg1)->push_back((Dali::Actor const &)*arg2);
81875     } catch (std::out_of_range& e) {
81876       {
81877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81878       };
81879     } catch (std::exception& e) {
81880       {
81881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81882       };
81883     } catch (...) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81886       };
81887     }
81888   }
81889 }
81890
81891
81892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81893   unsigned long jresult ;
81894   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81895   std::vector< Dali::Actor >::size_type result;
81896
81897   arg1 = (std::vector< Dali::Actor > *)jarg1;
81898   {
81899     try {
81900       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81901     } catch (std::out_of_range& e) {
81902       {
81903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81904       };
81905     } catch (std::exception& e) {
81906       {
81907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81908       };
81909     } catch (...) {
81910       {
81911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81912       };
81913     }
81914   }
81915   jresult = (unsigned long)result;
81916   return jresult;
81917 }
81918
81919
81920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81921   unsigned long jresult ;
81922   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81923   std::vector< Dali::Actor >::size_type result;
81924
81925   arg1 = (std::vector< Dali::Actor > *)jarg1;
81926   {
81927     try {
81928       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81929     } catch (std::out_of_range& e) {
81930       {
81931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81932       };
81933     } catch (std::exception& e) {
81934       {
81935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81936       };
81937     } catch (...) {
81938       {
81939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81940       };
81941     }
81942   }
81943   jresult = (unsigned long)result;
81944   return jresult;
81945 }
81946
81947
81948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81949   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81950   std::vector< Dali::Actor >::size_type arg2 ;
81951
81952   arg1 = (std::vector< Dali::Actor > *)jarg1;
81953   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81954   {
81955     try {
81956       (arg1)->reserve(arg2);
81957     } catch (std::out_of_range& e) {
81958       {
81959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81960       };
81961     } catch (std::exception& e) {
81962       {
81963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81964       };
81965     } catch (...) {
81966       {
81967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81968       };
81969     }
81970   }
81971 }
81972
81973
81974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81975   void * jresult ;
81976   std::vector< Dali::Actor > *result = 0 ;
81977
81978   {
81979     try {
81980       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81992       };
81993     }
81994   }
81995   jresult = (void *)result;
81996   return jresult;
81997 }
81998
81999
82000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
82001   void * jresult ;
82002   std::vector< Dali::Actor > *arg1 = 0 ;
82003   std::vector< Dali::Actor > *result = 0 ;
82004
82005   arg1 = (std::vector< Dali::Actor > *)jarg1;
82006   if (!arg1) {
82007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82008     return 0;
82009   }
82010   {
82011     try {
82012       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
82013     } catch (std::out_of_range& e) {
82014       {
82015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82016       };
82017     } catch (std::exception& e) {
82018       {
82019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82020       };
82021     } catch (...) {
82022       {
82023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82024       };
82025     }
82026   }
82027   jresult = (void *)result;
82028   return jresult;
82029 }
82030
82031
82032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82033   void * jresult ;
82034   int arg1 ;
82035   std::vector< Dali::Actor > *result = 0 ;
82036
82037   arg1 = (int)jarg1;
82038   {
82039     try {
82040       try {
82041         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82042       }
82043       catch(std::out_of_range &_e) {
82044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82045         return 0;
82046       }
82047
82048     } catch (std::out_of_range& e) {
82049       {
82050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82051       };
82052     } catch (std::exception& e) {
82053       {
82054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82055       };
82056     } catch (...) {
82057       {
82058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82059       };
82060     }
82061   }
82062   jresult = (void *)result;
82063   return jresult;
82064 }
82065
82066
82067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82068   void * jresult ;
82069   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82070   int arg2 ;
82071   Dali::Actor result;
82072
82073   arg1 = (std::vector< Dali::Actor > *)jarg1;
82074   arg2 = (int)jarg2;
82075   {
82076     try {
82077       try {
82078         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82079       }
82080       catch(std::out_of_range &_e) {
82081         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82082         return 0;
82083       }
82084
82085     } catch (std::out_of_range& e) {
82086       {
82087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82088       };
82089     } catch (std::exception& e) {
82090       {
82091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82092       };
82093     } catch (...) {
82094       {
82095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82096       };
82097     }
82098   }
82099   jresult = new Dali::Actor((const Dali::Actor &)result);
82100   return jresult;
82101 }
82102
82103
82104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82105   void * jresult ;
82106   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82107   int arg2 ;
82108   Dali::Actor *result = 0 ;
82109
82110   arg1 = (std::vector< Dali::Actor > *)jarg1;
82111   arg2 = (int)jarg2;
82112   {
82113     try {
82114       try {
82115         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82116       }
82117       catch(std::out_of_range &_e) {
82118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82119         return 0;
82120       }
82121
82122     } catch (std::out_of_range& e) {
82123       {
82124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82125       };
82126     } catch (std::exception& e) {
82127       {
82128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82129       };
82130     } catch (...) {
82131       {
82132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82133       };
82134     }
82135   }
82136   jresult = (void *)result;
82137   return jresult;
82138 }
82139
82140
82141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82142   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82143   int arg2 ;
82144   Dali::Actor *arg3 = 0 ;
82145
82146   arg1 = (std::vector< Dali::Actor > *)jarg1;
82147   arg2 = (int)jarg2;
82148   arg3 = (Dali::Actor *)jarg3;
82149   if (!arg3) {
82150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82151     return ;
82152   }
82153   {
82154     try {
82155       try {
82156         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82157       }
82158       catch(std::out_of_range &_e) {
82159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82160         return ;
82161       }
82162
82163     } catch (std::out_of_range& e) {
82164       {
82165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82166       };
82167     } catch (std::exception& e) {
82168       {
82169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82174       };
82175     }
82176   }
82177 }
82178
82179
82180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82181   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82182   std::vector< Dali::Actor > *arg2 = 0 ;
82183
82184   arg1 = (std::vector< Dali::Actor > *)jarg1;
82185   arg2 = (std::vector< Dali::Actor > *)jarg2;
82186   if (!arg2) {
82187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82188     return ;
82189   }
82190   {
82191     try {
82192       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82193     } catch (std::out_of_range& e) {
82194       {
82195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82196       };
82197     } catch (std::exception& e) {
82198       {
82199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82200       };
82201     } catch (...) {
82202       {
82203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82204       };
82205     }
82206   }
82207 }
82208
82209
82210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82211   void * jresult ;
82212   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82213   int arg2 ;
82214   int arg3 ;
82215   std::vector< Dali::Actor > *result = 0 ;
82216
82217   arg1 = (std::vector< Dali::Actor > *)jarg1;
82218   arg2 = (int)jarg2;
82219   arg3 = (int)jarg3;
82220   {
82221     try {
82222       try {
82223         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82224       }
82225       catch(std::out_of_range &_e) {
82226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82227         return 0;
82228       }
82229       catch(std::invalid_argument &_e) {
82230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82231         return 0;
82232       }
82233
82234     } catch (std::out_of_range& e) {
82235       {
82236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (std::exception& e) {
82239       {
82240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (...) {
82243       {
82244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82245       };
82246     }
82247   }
82248   jresult = (void *)result;
82249   return jresult;
82250 }
82251
82252
82253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82254   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82255   int arg2 ;
82256   Dali::Actor *arg3 = 0 ;
82257
82258   arg1 = (std::vector< Dali::Actor > *)jarg1;
82259   arg2 = (int)jarg2;
82260   arg3 = (Dali::Actor *)jarg3;
82261   if (!arg3) {
82262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82263     return ;
82264   }
82265   {
82266     try {
82267       try {
82268         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82269       }
82270       catch(std::out_of_range &_e) {
82271         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82272         return ;
82273       }
82274
82275     } catch (std::out_of_range& e) {
82276       {
82277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82278       };
82279     } catch (std::exception& e) {
82280       {
82281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82282       };
82283     } catch (...) {
82284       {
82285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82286       };
82287     }
82288   }
82289 }
82290
82291
82292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82293   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82294   int arg2 ;
82295   std::vector< Dali::Actor > *arg3 = 0 ;
82296
82297   arg1 = (std::vector< Dali::Actor > *)jarg1;
82298   arg2 = (int)jarg2;
82299   arg3 = (std::vector< Dali::Actor > *)jarg3;
82300   if (!arg3) {
82301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82302     return ;
82303   }
82304   {
82305     try {
82306       try {
82307         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82308       }
82309       catch(std::out_of_range &_e) {
82310         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82311         return ;
82312       }
82313
82314     } catch (std::out_of_range& e) {
82315       {
82316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82317       };
82318     } catch (std::exception& e) {
82319       {
82320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82321       };
82322     } catch (...) {
82323       {
82324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82325       };
82326     }
82327   }
82328 }
82329
82330
82331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82332   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82333   int arg2 ;
82334
82335   arg1 = (std::vector< Dali::Actor > *)jarg1;
82336   arg2 = (int)jarg2;
82337   {
82338     try {
82339       try {
82340         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82341       }
82342       catch(std::out_of_range &_e) {
82343         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82344         return ;
82345       }
82346
82347     } catch (std::out_of_range& e) {
82348       {
82349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82350       };
82351     } catch (std::exception& e) {
82352       {
82353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82354       };
82355     } catch (...) {
82356       {
82357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82358       };
82359     }
82360   }
82361 }
82362
82363
82364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82365   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82366   int arg2 ;
82367   int arg3 ;
82368
82369   arg1 = (std::vector< Dali::Actor > *)jarg1;
82370   arg2 = (int)jarg2;
82371   arg3 = (int)jarg3;
82372   {
82373     try {
82374       try {
82375         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82376       }
82377       catch(std::out_of_range &_e) {
82378         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82379         return ;
82380       }
82381       catch(std::invalid_argument &_e) {
82382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82383         return ;
82384       }
82385
82386     } catch (std::out_of_range& e) {
82387       {
82388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82389       };
82390     } catch (std::exception& e) {
82391       {
82392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82397       };
82398     }
82399   }
82400 }
82401
82402
82403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82404   void * jresult ;
82405   Dali::Actor *arg1 = 0 ;
82406   int arg2 ;
82407   std::vector< Dali::Actor > *result = 0 ;
82408
82409   arg1 = (Dali::Actor *)jarg1;
82410   if (!arg1) {
82411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82412     return 0;
82413   }
82414   arg2 = (int)jarg2;
82415   {
82416     try {
82417       try {
82418         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82419       }
82420       catch(std::out_of_range &_e) {
82421         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82422         return 0;
82423       }
82424
82425     } catch (std::out_of_range& e) {
82426       {
82427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82428       };
82429     } catch (std::exception& e) {
82430       {
82431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82432       };
82433     } catch (...) {
82434       {
82435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82436       };
82437     }
82438   }
82439   jresult = (void *)result;
82440   return jresult;
82441 }
82442
82443
82444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82445   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82446
82447   arg1 = (std::vector< Dali::Actor > *)jarg1;
82448   {
82449     try {
82450       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82458       };
82459     } catch (...) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82462       };
82463     }
82464   }
82465 }
82466
82467
82468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82469   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82470   int arg2 ;
82471   int arg3 ;
82472
82473   arg1 = (std::vector< Dali::Actor > *)jarg1;
82474   arg2 = (int)jarg2;
82475   arg3 = (int)jarg3;
82476   {
82477     try {
82478       try {
82479         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82480       }
82481       catch(std::out_of_range &_e) {
82482         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82483         return ;
82484       }
82485       catch(std::invalid_argument &_e) {
82486         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82487         return ;
82488       }
82489
82490     } catch (std::out_of_range& e) {
82491       {
82492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82493       };
82494     } catch (std::exception& e) {
82495       {
82496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82497       };
82498     } catch (...) {
82499       {
82500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82501       };
82502     }
82503   }
82504 }
82505
82506
82507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82508   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82509   int arg2 ;
82510   std::vector< Dali::Actor > *arg3 = 0 ;
82511
82512   arg1 = (std::vector< Dali::Actor > *)jarg1;
82513   arg2 = (int)jarg2;
82514   arg3 = (std::vector< Dali::Actor > *)jarg3;
82515   if (!arg3) {
82516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82517     return ;
82518   }
82519   {
82520     try {
82521       try {
82522         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82523       }
82524       catch(std::out_of_range &_e) {
82525         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82526         return ;
82527       }
82528
82529     } catch (std::out_of_range& e) {
82530       {
82531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82532       };
82533     } catch (std::exception& e) {
82534       {
82535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82536       };
82537     } catch (...) {
82538       {
82539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82540       };
82541     }
82542   }
82543 }
82544
82545
82546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82547   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82548
82549   arg1 = (std::vector< Dali::Actor > *)jarg1;
82550   {
82551     try {
82552       delete arg1;
82553     } catch (std::out_of_range& e) {
82554       {
82555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82556       };
82557     } catch (std::exception& e) {
82558       {
82559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82560       };
82561     } catch (...) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82564       };
82565     }
82566   }
82567 }
82568
82569
82570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82571   unsigned int jresult ;
82572   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82573   bool result;
82574
82575   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82576   {
82577     try {
82578       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82579     } catch (std::out_of_range& e) {
82580       {
82581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (std::exception& e) {
82584       {
82585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82586       };
82587     } catch (...) {
82588       {
82589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82590       };
82591     }
82592   }
82593   jresult = result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82599   unsigned long jresult ;
82600   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82601   std::size_t result;
82602
82603   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82604   {
82605     try {
82606       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82607     } catch (std::out_of_range& e) {
82608       {
82609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (std::exception& e) {
82612       {
82613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82614       };
82615     } catch (...) {
82616       {
82617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82618       };
82619     }
82620   }
82621   jresult = (unsigned long)result;
82622   return jresult;
82623 }
82624
82625
82626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82627   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82628   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82629
82630   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82631   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82632   {
82633     try {
82634       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82635     } catch (std::out_of_range& e) {
82636       {
82637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82638       };
82639     } catch (std::exception& e) {
82640       {
82641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (...) {
82644       {
82645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82646       };
82647     }
82648   }
82649 }
82650
82651
82652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82653   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82654   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82655
82656   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82657   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82658   {
82659     try {
82660       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82668       };
82669     } catch (...) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82672       };
82673     }
82674   }
82675 }
82676
82677
82678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82679   unsigned int jresult ;
82680   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82681   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82682   bool result;
82683
82684   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82685   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82686   if (!arg2) {
82687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82688     return 0;
82689   }
82690   {
82691     try {
82692       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82693     } catch (std::out_of_range& e) {
82694       {
82695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82696       };
82697     } catch (std::exception& e) {
82698       {
82699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (...) {
82702       {
82703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82704       };
82705     }
82706   }
82707   jresult = result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82713   void * jresult ;
82714   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82715
82716   {
82717     try {
82718       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82726       };
82727     } catch (...) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82730       };
82731     }
82732   }
82733   jresult = (void *)result;
82734   return jresult;
82735 }
82736
82737
82738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82739   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82740
82741   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82742   {
82743     try {
82744       delete arg1;
82745     } catch (std::out_of_range& e) {
82746       {
82747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82748       };
82749     } catch (std::exception& e) {
82750       {
82751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82752       };
82753     } catch (...) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82756       };
82757     }
82758   }
82759 }
82760
82761
82762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82763   unsigned int jresult ;
82764   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82765   bool result;
82766
82767   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82768   {
82769     try {
82770       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);
82771     } catch (std::out_of_range& e) {
82772       {
82773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (std::exception& e) {
82776       {
82777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82778       };
82779     } catch (...) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82782       };
82783     }
82784   }
82785   jresult = result;
82786   return jresult;
82787 }
82788
82789
82790 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82791   unsigned long jresult ;
82792   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82793   std::size_t result;
82794
82795   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82796   {
82797     try {
82798       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);
82799     } catch (std::out_of_range& e) {
82800       {
82801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82802       };
82803     } catch (std::exception& e) {
82804       {
82805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82806       };
82807     } catch (...) {
82808       {
82809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82810       };
82811     }
82812   }
82813   jresult = (unsigned long)result;
82814   return jresult;
82815 }
82816
82817
82818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82819   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82820   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82821
82822   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82823   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82824   {
82825     try {
82826       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82827     } catch (std::out_of_range& e) {
82828       {
82829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82830       };
82831     } catch (std::exception& e) {
82832       {
82833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82834       };
82835     } catch (...) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82838       };
82839     }
82840   }
82841 }
82842
82843
82844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82845   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82846   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82847
82848   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82849   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82850   {
82851     try {
82852       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82853     } catch (std::out_of_range& e) {
82854       {
82855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82856       };
82857     } catch (std::exception& e) {
82858       {
82859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82860       };
82861     } catch (...) {
82862       {
82863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82864       };
82865     }
82866   }
82867 }
82868
82869
82870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82871   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82872   Dali::Actor arg2 ;
82873   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82874   Dali::Actor *argp2 ;
82875
82876   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82877   argp2 = (Dali::Actor *)jarg2;
82878   if (!argp2) {
82879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82880     return ;
82881   }
82882   arg2 = *argp2;
82883   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82884   {
82885     try {
82886       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82887     } catch (std::out_of_range& e) {
82888       {
82889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82890       };
82891     } catch (std::exception& e) {
82892       {
82893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82894       };
82895     } catch (...) {
82896       {
82897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82898       };
82899     }
82900   }
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82905   void * jresult ;
82906   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82907
82908   {
82909     try {
82910       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82911     } catch (std::out_of_range& e) {
82912       {
82913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82914       };
82915     } catch (std::exception& e) {
82916       {
82917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82918       };
82919     } catch (...) {
82920       {
82921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82922       };
82923     }
82924   }
82925   jresult = (void *)result;
82926   return jresult;
82927 }
82928
82929
82930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82931   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82932
82933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82934   {
82935     try {
82936       delete arg1;
82937     } catch (std::out_of_range& e) {
82938       {
82939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82940       };
82941     } catch (std::exception& e) {
82942       {
82943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82944       };
82945     } catch (...) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82948       };
82949     }
82950   }
82951 }
82952
82953
82954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82955   unsigned int jresult ;
82956   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82957   bool result;
82958
82959   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82960   {
82961     try {
82962       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82963     } catch (std::out_of_range& e) {
82964       {
82965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (std::exception& e) {
82968       {
82969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82970       };
82971     } catch (...) {
82972       {
82973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82974       };
82975     }
82976   }
82977   jresult = result;
82978   return jresult;
82979 }
82980
82981
82982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82983   unsigned long jresult ;
82984   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82985   std::size_t result;
82986
82987   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82988   {
82989     try {
82990       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82991     } catch (std::out_of_range& e) {
82992       {
82993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82994       };
82995     } catch (std::exception& e) {
82996       {
82997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82998       };
82999     } catch (...) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83002       };
83003     }
83004   }
83005   jresult = (unsigned long)result;
83006   return jresult;
83007 }
83008
83009
83010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
83011   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83012   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83013
83014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83015   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83016   {
83017     try {
83018       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
83019     } catch (std::out_of_range& e) {
83020       {
83021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83022       };
83023     } catch (std::exception& e) {
83024       {
83025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83026       };
83027     } catch (...) {
83028       {
83029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83030       };
83031     }
83032   }
83033 }
83034
83035
83036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83037   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83038   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83039
83040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83041   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83042   {
83043     try {
83044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83045     } catch (std::out_of_range& e) {
83046       {
83047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83048       };
83049     } catch (std::exception& e) {
83050       {
83051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83052       };
83053     } catch (...) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83056       };
83057     }
83058   }
83059 }
83060
83061
83062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83063   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83064   Dali::Actor arg2 ;
83065   Dali::Actor arg3 ;
83066   Dali::Actor *argp2 ;
83067   Dali::Actor *argp3 ;
83068
83069   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83070   argp2 = (Dali::Actor *)jarg2;
83071   if (!argp2) {
83072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83073     return ;
83074   }
83075   arg2 = *argp2;
83076   argp3 = (Dali::Actor *)jarg3;
83077   if (!argp3) {
83078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83079     return ;
83080   }
83081   arg3 = *argp3;
83082   {
83083     try {
83084       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83085     } catch (std::out_of_range& e) {
83086       {
83087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83088       };
83089     } catch (std::exception& e) {
83090       {
83091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83092       };
83093     } catch (...) {
83094       {
83095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83096       };
83097     }
83098   }
83099 }
83100
83101
83102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83103   void * jresult ;
83104   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83105
83106   {
83107     try {
83108       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83109     } catch (std::out_of_range& e) {
83110       {
83111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83112       };
83113     } catch (std::exception& e) {
83114       {
83115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83120       };
83121     }
83122   }
83123   jresult = (void *)result;
83124   return jresult;
83125 }
83126
83127
83128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83129   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83130
83131   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83132   {
83133     try {
83134       delete arg1;
83135     } catch (std::out_of_range& e) {
83136       {
83137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83138       };
83139     } catch (std::exception& e) {
83140       {
83141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83142       };
83143     } catch (...) {
83144       {
83145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83146       };
83147     }
83148   }
83149 }
83150
83151
83152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83153   unsigned int jresult ;
83154   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83155   bool result;
83156
83157   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83158   {
83159     try {
83160       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83161     } catch (std::out_of_range& e) {
83162       {
83163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (std::exception& e) {
83166       {
83167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (...) {
83170       {
83171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83172       };
83173     }
83174   }
83175   jresult = result;
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83181   unsigned long jresult ;
83182   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83183   std::size_t result;
83184
83185   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83186   {
83187     try {
83188       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83189     } catch (std::out_of_range& e) {
83190       {
83191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (std::exception& e) {
83194       {
83195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83200       };
83201     }
83202   }
83203   jresult = (unsigned long)result;
83204   return jresult;
83205 }
83206
83207
83208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83209   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83210   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83211
83212   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83213   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83214   {
83215     try {
83216       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83217     } catch (std::out_of_range& e) {
83218       {
83219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83220       };
83221     } catch (std::exception& e) {
83222       {
83223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83224       };
83225     } catch (...) {
83226       {
83227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83228       };
83229     }
83230   }
83231 }
83232
83233
83234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83235   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83236   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83237
83238   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83239   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83240   {
83241     try {
83242       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83243     } catch (std::out_of_range& e) {
83244       {
83245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83246       };
83247     } catch (std::exception& e) {
83248       {
83249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83254       };
83255     }
83256   }
83257 }
83258
83259
83260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83261   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83262   Dali::Actor arg2 ;
83263   bool arg3 ;
83264   Dali::Actor *argp2 ;
83265
83266   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83267   argp2 = (Dali::Actor *)jarg2;
83268   if (!argp2) {
83269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83270     return ;
83271   }
83272   arg2 = *argp2;
83273   arg3 = jarg3 ? true : false;
83274   {
83275     try {
83276       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83284       };
83285     } catch (...) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83288       };
83289     }
83290   }
83291 }
83292
83293
83294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83295   void * jresult ;
83296   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83297
83298   {
83299     try {
83300       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83301     } catch (std::out_of_range& e) {
83302       {
83303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83304       };
83305     } catch (std::exception& e) {
83306       {
83307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (...) {
83310       {
83311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83312       };
83313     }
83314   }
83315   jresult = (void *)result;
83316   return jresult;
83317 }
83318
83319
83320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83321   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83322
83323   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83324   {
83325     try {
83326       delete arg1;
83327     } catch (std::out_of_range& e) {
83328       {
83329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83330       };
83331     } catch (std::exception& e) {
83332       {
83333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83334       };
83335     } catch (...) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83338       };
83339     }
83340   }
83341 }
83342
83343
83344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83345   unsigned int jresult ;
83346   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83347   bool result;
83348
83349   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83350   {
83351     try {
83352       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);
83353     } catch (std::out_of_range& e) {
83354       {
83355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83356       };
83357     } catch (std::exception& e) {
83358       {
83359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83360       };
83361     } catch (...) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83364       };
83365     }
83366   }
83367   jresult = result;
83368   return jresult;
83369 }
83370
83371
83372 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83373   unsigned long jresult ;
83374   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83375   std::size_t result;
83376
83377   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83378   {
83379     try {
83380       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);
83381     } catch (std::out_of_range& e) {
83382       {
83383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83384       };
83385     } catch (std::exception& e) {
83386       {
83387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (...) {
83390       {
83391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83392       };
83393     }
83394   }
83395   jresult = (unsigned long)result;
83396   return jresult;
83397 }
83398
83399
83400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83401   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83402   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83403
83404   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83405   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83406   {
83407     try {
83408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83409     } catch (std::out_of_range& e) {
83410       {
83411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83412       };
83413     } catch (std::exception& e) {
83414       {
83415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83416       };
83417     } catch (...) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83420       };
83421     }
83422   }
83423 }
83424
83425
83426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83427   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83428   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83429
83430   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83431   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83432   {
83433     try {
83434       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83435     } catch (std::out_of_range& e) {
83436       {
83437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (std::exception& e) {
83440       {
83441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83442       };
83443     } catch (...) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83446       };
83447     }
83448   }
83449 }
83450
83451
83452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83453   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83454   Dali::Toolkit::StyleManager arg2 ;
83455   Dali::StyleChange::Type arg3 ;
83456   Dali::Toolkit::StyleManager *argp2 ;
83457
83458   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83459   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83460   if (!argp2) {
83461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83462     return ;
83463   }
83464   arg2 = *argp2;
83465   arg3 = (Dali::StyleChange::Type)jarg3;
83466   {
83467     try {
83468       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83469     } catch (std::out_of_range& e) {
83470       {
83471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83472       };
83473     } catch (std::exception& e) {
83474       {
83475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83476       };
83477     } catch (...) {
83478       {
83479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83480       };
83481     }
83482   }
83483 }
83484
83485
83486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83487   void * jresult ;
83488   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83489
83490   {
83491     try {
83492       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83493     } catch (std::out_of_range& e) {
83494       {
83495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83496       };
83497     } catch (std::exception& e) {
83498       {
83499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83500       };
83501     } catch (...) {
83502       {
83503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83504       };
83505     }
83506   }
83507   jresult = (void *)result;
83508   return jresult;
83509 }
83510
83511
83512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83513   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83514
83515   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83516   {
83517     try {
83518       delete arg1;
83519     } catch (std::out_of_range& e) {
83520       {
83521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83522       };
83523     } catch (std::exception& e) {
83524       {
83525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83526       };
83527     } catch (...) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83530       };
83531     }
83532   }
83533 }
83534
83535
83536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83537   unsigned int jresult ;
83538   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83539   bool result;
83540
83541   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83542   {
83543     try {
83544       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83545     } catch (std::out_of_range& e) {
83546       {
83547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83548       };
83549     } catch (std::exception& e) {
83550       {
83551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83552       };
83553     } catch (...) {
83554       {
83555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83556       };
83557     }
83558   }
83559   jresult = result;
83560   return jresult;
83561 }
83562
83563
83564 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83565   unsigned long jresult ;
83566   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83567   std::size_t result;
83568
83569   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83570   {
83571     try {
83572       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83573     } catch (std::out_of_range& e) {
83574       {
83575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83576       };
83577     } catch (std::exception& e) {
83578       {
83579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83580       };
83581     } catch (...) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83584       };
83585     }
83586   }
83587   jresult = (unsigned long)result;
83588   return jresult;
83589 }
83590
83591
83592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83593   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83594   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83595
83596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83597   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83598   {
83599     try {
83600       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83601     } catch (std::out_of_range& e) {
83602       {
83603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83604       };
83605     } catch (std::exception& e) {
83606       {
83607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83608       };
83609     } catch (...) {
83610       {
83611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83612       };
83613     }
83614   }
83615 }
83616
83617
83618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83619   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83620   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83621
83622   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83623   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83624   {
83625     try {
83626       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83627     } catch (std::out_of_range& e) {
83628       {
83629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83630       };
83631     } catch (std::exception& e) {
83632       {
83633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83634       };
83635     } catch (...) {
83636       {
83637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83638       };
83639     }
83640   }
83641 }
83642
83643
83644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83645   unsigned int jresult ;
83646   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83647   Dali::Toolkit::Button arg2 ;
83648   Dali::Toolkit::Button *argp2 ;
83649   bool result;
83650
83651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83652   argp2 = (Dali::Toolkit::Button *)jarg2;
83653   if (!argp2) {
83654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83655     return 0;
83656   }
83657   arg2 = *argp2;
83658   {
83659     try {
83660       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83661     } catch (std::out_of_range& e) {
83662       {
83663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83664       };
83665     } catch (std::exception& e) {
83666       {
83667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83668       };
83669     } catch (...) {
83670       {
83671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83672       };
83673     }
83674   }
83675   jresult = result;
83676   return jresult;
83677 }
83678
83679
83680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83681   void * jresult ;
83682   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83683
83684   {
83685     try {
83686       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83687     } catch (std::out_of_range& e) {
83688       {
83689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (std::exception& e) {
83692       {
83693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (...) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83698       };
83699     }
83700   }
83701   jresult = (void *)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83707   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83708
83709   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83710   {
83711     try {
83712       delete arg1;
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83720       };
83721     } catch (...) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83724       };
83725     }
83726   }
83727 }
83728
83729
83730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83731   unsigned int jresult ;
83732   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83733   bool result;
83734
83735   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83736   {
83737     try {
83738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83739     } catch (std::out_of_range& e) {
83740       {
83741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83742       };
83743     } catch (std::exception& e) {
83744       {
83745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83746       };
83747     } catch (...) {
83748       {
83749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83750       };
83751     }
83752   }
83753   jresult = result;
83754   return jresult;
83755 }
83756
83757
83758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83759   unsigned long jresult ;
83760   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83761   std::size_t result;
83762
83763   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83764   {
83765     try {
83766       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83767     } catch (std::out_of_range& e) {
83768       {
83769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83770       };
83771     } catch (std::exception& e) {
83772       {
83773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83774       };
83775     } catch (...) {
83776       {
83777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83778       };
83779     }
83780   }
83781   jresult = (unsigned long)result;
83782   return jresult;
83783 }
83784
83785
83786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83787   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83788   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83789
83790   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83791   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83792   {
83793     try {
83794       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83795     } catch (std::out_of_range& e) {
83796       {
83797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83798       };
83799     } catch (std::exception& e) {
83800       {
83801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83806       };
83807     }
83808   }
83809 }
83810
83811
83812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83813   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83814   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83815
83816   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83817   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83818   {
83819     try {
83820       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (...) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83832       };
83833     }
83834   }
83835 }
83836
83837
83838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83839   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83840   Dali::Toolkit::GaussianBlurView arg2 ;
83841   Dali::Toolkit::GaussianBlurView *argp2 ;
83842
83843   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83844   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83845   if (!argp2) {
83846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83847     return ;
83848   }
83849   arg2 = *argp2;
83850   {
83851     try {
83852       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83853     } catch (std::out_of_range& e) {
83854       {
83855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83856       };
83857     } catch (std::exception& e) {
83858       {
83859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83860       };
83861     } catch (...) {
83862       {
83863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83864       };
83865     }
83866   }
83867 }
83868
83869
83870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83871   void * jresult ;
83872   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83873
83874   {
83875     try {
83876       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83877     } catch (std::out_of_range& e) {
83878       {
83879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83880       };
83881     } catch (std::exception& e) {
83882       {
83883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83884       };
83885     } catch (...) {
83886       {
83887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83888       };
83889     }
83890   }
83891   jresult = (void *)result;
83892   return jresult;
83893 }
83894
83895
83896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83897   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83898
83899   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83900   {
83901     try {
83902       delete arg1;
83903     } catch (std::out_of_range& e) {
83904       {
83905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83906       };
83907     } catch (std::exception& e) {
83908       {
83909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83910       };
83911     } catch (...) {
83912       {
83913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83914       };
83915     }
83916   }
83917 }
83918
83919
83920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83921   unsigned int jresult ;
83922   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83923   bool result;
83924
83925   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83926   {
83927     try {
83928       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);
83929     } catch (std::out_of_range& e) {
83930       {
83931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83932       };
83933     } catch (std::exception& e) {
83934       {
83935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83936       };
83937     } catch (...) {
83938       {
83939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83940       };
83941     }
83942   }
83943   jresult = result;
83944   return jresult;
83945 }
83946
83947
83948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83949   unsigned long jresult ;
83950   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83951   std::size_t result;
83952
83953   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83954   {
83955     try {
83956       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);
83957     } catch (std::out_of_range& e) {
83958       {
83959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (std::exception& e) {
83962       {
83963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83964       };
83965     } catch (...) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83968       };
83969     }
83970   }
83971   jresult = (unsigned long)result;
83972   return jresult;
83973 }
83974
83975
83976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83977   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83978   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83979
83980   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83981   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83982   {
83983     try {
83984       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83985     } catch (std::out_of_range& e) {
83986       {
83987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83988       };
83989     } catch (std::exception& e) {
83990       {
83991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83996       };
83997     }
83998   }
83999 }
84000
84001
84002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
84003   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84004   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
84005
84006   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84007   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
84008   {
84009     try {
84010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
84011     } catch (std::out_of_range& e) {
84012       {
84013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84014       };
84015     } catch (std::exception& e) {
84016       {
84017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84018       };
84019     } catch (...) {
84020       {
84021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84022       };
84023     }
84024   }
84025 }
84026
84027
84028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
84029   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84030   Dali::Toolkit::PageTurnView arg2 ;
84031   unsigned int arg3 ;
84032   bool arg4 ;
84033   Dali::Toolkit::PageTurnView *argp2 ;
84034
84035   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84036   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84037   if (!argp2) {
84038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84039     return ;
84040   }
84041   arg2 = *argp2;
84042   arg3 = (unsigned int)jarg3;
84043   arg4 = jarg4 ? true : false;
84044   {
84045     try {
84046       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84047     } catch (std::out_of_range& e) {
84048       {
84049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84050       };
84051     } catch (std::exception& e) {
84052       {
84053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84054       };
84055     } catch (...) {
84056       {
84057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84058       };
84059     }
84060   }
84061 }
84062
84063
84064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84065   void * jresult ;
84066   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84067
84068   {
84069     try {
84070       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84071     } catch (std::out_of_range& e) {
84072       {
84073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84074       };
84075     } catch (std::exception& e) {
84076       {
84077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84078       };
84079     } catch (...) {
84080       {
84081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84082       };
84083     }
84084   }
84085   jresult = (void *)result;
84086   return jresult;
84087 }
84088
84089
84090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84091   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84092
84093   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84094   {
84095     try {
84096       delete arg1;
84097     } catch (std::out_of_range& e) {
84098       {
84099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84100       };
84101     } catch (std::exception& e) {
84102       {
84103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84104       };
84105     } catch (...) {
84106       {
84107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84108       };
84109     }
84110   }
84111 }
84112
84113
84114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84115   unsigned int jresult ;
84116   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84117   bool result;
84118
84119   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84120   {
84121     try {
84122       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84123     } catch (std::out_of_range& e) {
84124       {
84125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84126       };
84127     } catch (std::exception& e) {
84128       {
84129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84130       };
84131     } catch (...) {
84132       {
84133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84134       };
84135     }
84136   }
84137   jresult = result;
84138   return jresult;
84139 }
84140
84141
84142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84143   unsigned long jresult ;
84144   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84145   std::size_t result;
84146
84147   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84148   {
84149     try {
84150       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84151     } catch (std::out_of_range& e) {
84152       {
84153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84154       };
84155     } catch (std::exception& e) {
84156       {
84157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84158       };
84159     } catch (...) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84162       };
84163     }
84164   }
84165   jresult = (unsigned long)result;
84166   return jresult;
84167 }
84168
84169
84170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84171   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84172   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84173
84174   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84175   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84176   {
84177     try {
84178       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84179     } catch (std::out_of_range& e) {
84180       {
84181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84182       };
84183     } catch (std::exception& e) {
84184       {
84185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84186       };
84187     } catch (...) {
84188       {
84189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84190       };
84191     }
84192   }
84193 }
84194
84195
84196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84197   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84198   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84199
84200   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84201   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84202   {
84203     try {
84204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84216       };
84217     }
84218   }
84219 }
84220
84221
84222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84223   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84224   Dali::Toolkit::PageTurnView arg2 ;
84225   Dali::Toolkit::PageTurnView *argp2 ;
84226
84227   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84228   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84229   if (!argp2) {
84230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84231     return ;
84232   }
84233   arg2 = *argp2;
84234   {
84235     try {
84236       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84237     } catch (std::out_of_range& e) {
84238       {
84239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84240       };
84241     } catch (std::exception& e) {
84242       {
84243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84244       };
84245     } catch (...) {
84246       {
84247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84248       };
84249     }
84250   }
84251 }
84252
84253
84254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84255   void * jresult ;
84256   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84257
84258   {
84259     try {
84260       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84261     } catch (std::out_of_range& e) {
84262       {
84263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84264       };
84265     } catch (std::exception& e) {
84266       {
84267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84268       };
84269     } catch (...) {
84270       {
84271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84272       };
84273     }
84274   }
84275   jresult = (void *)result;
84276   return jresult;
84277 }
84278
84279
84280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84281   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84282
84283   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84284   {
84285     try {
84286       delete arg1;
84287     } catch (std::out_of_range& e) {
84288       {
84289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84290       };
84291     } catch (std::exception& e) {
84292       {
84293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84294       };
84295     } catch (...) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84298       };
84299     }
84300   }
84301 }
84302
84303
84304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84305   unsigned int jresult ;
84306   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84307   bool result;
84308
84309   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84310   {
84311     try {
84312       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);
84313     } catch (std::out_of_range& e) {
84314       {
84315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84316       };
84317     } catch (std::exception& e) {
84318       {
84319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84320       };
84321     } catch (...) {
84322       {
84323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84324       };
84325     }
84326   }
84327   jresult = result;
84328   return jresult;
84329 }
84330
84331
84332 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84333   unsigned long jresult ;
84334   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84335   std::size_t result;
84336
84337   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84338   {
84339     try {
84340       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);
84341     } catch (std::out_of_range& e) {
84342       {
84343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84344       };
84345     } catch (std::exception& e) {
84346       {
84347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (...) {
84350       {
84351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84352       };
84353     }
84354   }
84355   jresult = (unsigned long)result;
84356   return jresult;
84357 }
84358
84359
84360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84361   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84362   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84363
84364   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84365   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84366   {
84367     try {
84368       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84369     } catch (std::out_of_range& e) {
84370       {
84371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84372       };
84373     } catch (std::exception& e) {
84374       {
84375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84376       };
84377     } catch (...) {
84378       {
84379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84380       };
84381     }
84382   }
84383 }
84384
84385
84386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84387   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84388   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84389
84390   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84391   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84392   {
84393     try {
84394       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84395     } catch (std::out_of_range& e) {
84396       {
84397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84398       };
84399     } catch (std::exception& e) {
84400       {
84401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84402       };
84403     } catch (...) {
84404       {
84405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84406       };
84407     }
84408   }
84409 }
84410
84411
84412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84413   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84414   Dali::Toolkit::ProgressBar arg2 ;
84415   float arg3 ;
84416   float arg4 ;
84417   Dali::Toolkit::ProgressBar *argp2 ;
84418
84419   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84420   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84421   if (!argp2) {
84422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84423     return ;
84424   }
84425   arg2 = *argp2;
84426   arg3 = (float)jarg3;
84427   arg4 = (float)jarg4;
84428   {
84429     try {
84430       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84431     } catch (std::out_of_range& e) {
84432       {
84433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84434       };
84435     } catch (std::exception& e) {
84436       {
84437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (...) {
84440       {
84441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84442       };
84443     }
84444   }
84445 }
84446
84447
84448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84449   void * jresult ;
84450   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84451
84452   {
84453     try {
84454       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84455     } catch (std::out_of_range& e) {
84456       {
84457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84458       };
84459     } catch (std::exception& e) {
84460       {
84461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84462       };
84463     } catch (...) {
84464       {
84465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84466       };
84467     }
84468   }
84469   jresult = (void *)result;
84470   return jresult;
84471 }
84472
84473
84474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84475   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84476
84477   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84478   {
84479     try {
84480       delete arg1;
84481     } catch (std::out_of_range& e) {
84482       {
84483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84484       };
84485     } catch (std::exception& e) {
84486       {
84487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84492       };
84493     }
84494   }
84495 }
84496
84497
84498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84499   unsigned int jresult ;
84500   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84501   bool result;
84502
84503   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84504   {
84505     try {
84506       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);
84507     } catch (std::out_of_range& e) {
84508       {
84509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (std::exception& e) {
84512       {
84513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84514       };
84515     } catch (...) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84518       };
84519     }
84520   }
84521   jresult = result;
84522   return jresult;
84523 }
84524
84525
84526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84527   unsigned long jresult ;
84528   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84529   std::size_t result;
84530
84531   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84532   {
84533     try {
84534       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);
84535     } catch (std::out_of_range& e) {
84536       {
84537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84538       };
84539     } catch (std::exception& e) {
84540       {
84541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84542       };
84543     } catch (...) {
84544       {
84545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84546       };
84547     }
84548   }
84549   jresult = (unsigned long)result;
84550   return jresult;
84551 }
84552
84553
84554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84555   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84556   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84557
84558   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84559   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84560   {
84561     try {
84562       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84563     } catch (std::out_of_range& e) {
84564       {
84565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84566       };
84567     } catch (std::exception& e) {
84568       {
84569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84574       };
84575     }
84576   }
84577 }
84578
84579
84580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84581   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84582   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84583
84584   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84585   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84586   {
84587     try {
84588       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84589     } catch (std::out_of_range& e) {
84590       {
84591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84592       };
84593     } catch (std::exception& e) {
84594       {
84595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84596       };
84597     } catch (...) {
84598       {
84599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84600       };
84601     }
84602   }
84603 }
84604
84605
84606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84607   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84608   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84609
84610   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84611   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84612   if (!arg2) {
84613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84614     return ;
84615   }
84616   {
84617     try {
84618       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84619     } catch (std::out_of_range& e) {
84620       {
84621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84622       };
84623     } catch (std::exception& e) {
84624       {
84625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84626       };
84627     } catch (...) {
84628       {
84629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84630       };
84631     }
84632   }
84633 }
84634
84635
84636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84637   void * jresult ;
84638   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84639
84640   {
84641     try {
84642       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84643     } catch (std::out_of_range& e) {
84644       {
84645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (std::exception& e) {
84648       {
84649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84650       };
84651     } catch (...) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84654       };
84655     }
84656   }
84657   jresult = (void *)result;
84658   return jresult;
84659 }
84660
84661
84662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84663   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84664
84665   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84666   {
84667     try {
84668       delete arg1;
84669     } catch (std::out_of_range& e) {
84670       {
84671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84672       };
84673     } catch (std::exception& e) {
84674       {
84675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84676       };
84677     } catch (...) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84680       };
84681     }
84682   }
84683 }
84684
84685
84686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84687   unsigned int jresult ;
84688   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84689   bool result;
84690
84691   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84692   {
84693     try {
84694       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84695     } catch (std::out_of_range& e) {
84696       {
84697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (std::exception& e) {
84700       {
84701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (...) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84706       };
84707     }
84708   }
84709   jresult = result;
84710   return jresult;
84711 }
84712
84713
84714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84715   unsigned long jresult ;
84716   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84717   std::size_t result;
84718
84719   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84720   {
84721     try {
84722       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84723     } catch (std::out_of_range& e) {
84724       {
84725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84726       };
84727     } catch (std::exception& e) {
84728       {
84729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84730       };
84731     } catch (...) {
84732       {
84733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84734       };
84735     }
84736   }
84737   jresult = (unsigned long)result;
84738   return jresult;
84739 }
84740
84741
84742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84743   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84744   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84745
84746   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84747   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84748   {
84749     try {
84750       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84762       };
84763     }
84764   }
84765 }
84766
84767
84768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84769   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84770   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84771
84772   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84773   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84774   {
84775     try {
84776       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84788       };
84789     }
84790   }
84791 }
84792
84793
84794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84795   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84796   Dali::Vector2 *arg2 = 0 ;
84797
84798   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84799   arg2 = (Dali::Vector2 *)jarg2;
84800   if (!arg2) {
84801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84802     return ;
84803   }
84804   {
84805     try {
84806       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84807     } catch (std::out_of_range& e) {
84808       {
84809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84810       };
84811     } catch (std::exception& e) {
84812       {
84813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84814       };
84815     } catch (...) {
84816       {
84817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84818       };
84819     }
84820   }
84821 }
84822
84823
84824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84825   void * jresult ;
84826   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84827
84828   {
84829     try {
84830       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84831     } catch (std::out_of_range& e) {
84832       {
84833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84834       };
84835     } catch (std::exception& e) {
84836       {
84837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84838       };
84839     } catch (...) {
84840       {
84841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84842       };
84843     }
84844   }
84845   jresult = (void *)result;
84846   return jresult;
84847 }
84848
84849
84850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84851   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84852
84853   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84854   {
84855     try {
84856       delete arg1;
84857     } catch (std::out_of_range& e) {
84858       {
84859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84860       };
84861     } catch (std::exception& e) {
84862       {
84863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84868       };
84869     }
84870   }
84871 }
84872
84873
84874
84875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84876   unsigned int jresult ;
84877   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84878   bool result;
84879
84880   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84881   {
84882     try {
84883       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);
84884     } catch (std::out_of_range& e) {
84885       {
84886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (std::exception& e) {
84889       {
84890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84895       };
84896     }
84897   }
84898   jresult = result;
84899   return jresult;
84900 }
84901
84902
84903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84904   unsigned long jresult ;
84905   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84906   std::size_t result;
84907
84908   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84909   {
84910     try {
84911       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);
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (...) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84923       };
84924     }
84925   }
84926   jresult = (unsigned long)result;
84927   return jresult;
84928 }
84929
84930
84931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84932   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84933   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84934
84935   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84936   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84937   {
84938     try {
84939       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84940     } catch (std::out_of_range& e) {
84941       {
84942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84943       };
84944     } catch (std::exception& e) {
84945       {
84946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84947       };
84948     } catch (...) {
84949       {
84950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84951       };
84952     }
84953   }
84954 }
84955
84956
84957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84958   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84959   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84960
84961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84962   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84963   {
84964     try {
84965       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84966     } catch (std::out_of_range& e) {
84967       {
84968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84969       };
84970     } catch (std::exception& e) {
84971       {
84972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84973       };
84974     } catch (...) {
84975       {
84976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84977       };
84978     }
84979   }
84980 }
84981
84982
84983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84984   unsigned int jresult ;
84985   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84986   Dali::Toolkit::Control arg2 ;
84987   Dali::KeyEvent *arg3 = 0 ;
84988   Dali::Toolkit::Control *argp2 ;
84989   bool result;
84990
84991   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84992   argp2 = (Dali::Toolkit::Control *)jarg2;
84993   if (!argp2) {
84994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84995     return 0;
84996   }
84997   arg2 = *argp2;
84998   arg3 = (Dali::KeyEvent *)jarg3;
84999   if (!arg3) {
85000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
85001     return 0;
85002   }
85003   {
85004     try {
85005       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);
85006     } catch (std::out_of_range& e) {
85007       {
85008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85009       };
85010     } catch (std::exception& e) {
85011       {
85012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85013       };
85014     } catch (...) {
85015       {
85016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85017       };
85018     }
85019   }
85020   jresult = result;
85021   return jresult;
85022 }
85023
85024
85025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
85026   void * jresult ;
85027   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
85028
85029   {
85030     try {
85031       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
85032     } catch (std::out_of_range& e) {
85033       {
85034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85035       };
85036     } catch (std::exception& e) {
85037       {
85038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85039       };
85040     } catch (...) {
85041       {
85042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85043       };
85044     }
85045   }
85046   jresult = (void *)result;
85047   return jresult;
85048 }
85049
85050
85051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85052   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85053
85054   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85055   {
85056     try {
85057       delete arg1;
85058     } catch (std::out_of_range& e) {
85059       {
85060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85061       };
85062     } catch (std::exception& e) {
85063       {
85064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85065       };
85066     } catch (...) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85069       };
85070     }
85071   }
85072 }
85073
85074
85075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85076   unsigned int jresult ;
85077   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85078   bool result;
85079
85080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85081   {
85082     try {
85083       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85084     } catch (std::out_of_range& e) {
85085       {
85086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85087       };
85088     } catch (std::exception& e) {
85089       {
85090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85091       };
85092     } catch (...) {
85093       {
85094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85095       };
85096     }
85097   }
85098   jresult = result;
85099   return jresult;
85100 }
85101
85102
85103 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85104   unsigned long jresult ;
85105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85106   std::size_t result;
85107
85108   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85109   {
85110     try {
85111       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126   jresult = (unsigned long)result;
85127   return jresult;
85128 }
85129
85130
85131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85132   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85133   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85134
85135   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85136   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85137   {
85138     try {
85139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85140     } catch (std::out_of_range& e) {
85141       {
85142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85143       };
85144     } catch (std::exception& e) {
85145       {
85146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85147       };
85148     } catch (...) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85151       };
85152     }
85153   }
85154 }
85155
85156
85157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85158   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85159   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85160
85161   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85162   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85163   {
85164     try {
85165       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85166     } catch (std::out_of_range& e) {
85167       {
85168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85169       };
85170     } catch (std::exception& e) {
85171       {
85172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85173       };
85174     } catch (...) {
85175       {
85176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85177       };
85178     }
85179   }
85180 }
85181
85182
85183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85184   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85185   Dali::Toolkit::Control arg2 ;
85186   Dali::Toolkit::Control *argp2 ;
85187
85188   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85189   argp2 = (Dali::Toolkit::Control *)jarg2;
85190   if (!argp2) {
85191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85192     return ;
85193   }
85194   arg2 = *argp2;
85195   {
85196     try {
85197       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85198     } catch (std::out_of_range& e) {
85199       {
85200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85201       };
85202     } catch (std::exception& e) {
85203       {
85204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85205       };
85206     } catch (...) {
85207       {
85208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85209       };
85210     }
85211   }
85212 }
85213
85214
85215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85216   void * jresult ;
85217   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85218
85219   {
85220     try {
85221       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85222     } catch (std::out_of_range& e) {
85223       {
85224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85225       };
85226     } catch (std::exception& e) {
85227       {
85228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85229       };
85230     } catch (...) {
85231       {
85232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85233       };
85234     }
85235   }
85236   jresult = (void *)result;
85237   return jresult;
85238 }
85239
85240
85241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85242   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85243
85244   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85245   {
85246     try {
85247       delete arg1;
85248     } catch (std::out_of_range& e) {
85249       {
85250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85251       };
85252     } catch (std::exception& e) {
85253       {
85254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85255       };
85256     } catch (...) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85259       };
85260     }
85261   }
85262 }
85263
85264
85265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85266   unsigned int jresult ;
85267   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85268   bool result;
85269
85270   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85271   {
85272     try {
85273       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85274     } catch (std::out_of_range& e) {
85275       {
85276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85277       };
85278     } catch (std::exception& e) {
85279       {
85280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85281       };
85282     } catch (...) {
85283       {
85284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85285       };
85286     }
85287   }
85288   jresult = result;
85289   return jresult;
85290 }
85291
85292
85293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85294   unsigned long jresult ;
85295   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85296   std::size_t result;
85297
85298   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85299   {
85300     try {
85301       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85302     } catch (std::out_of_range& e) {
85303       {
85304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85305       };
85306     } catch (std::exception& e) {
85307       {
85308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85309       };
85310     } catch (...) {
85311       {
85312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85313       };
85314     }
85315   }
85316   jresult = (unsigned long)result;
85317   return jresult;
85318 }
85319
85320
85321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85322   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85323   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85324
85325   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85326   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85327   {
85328     try {
85329       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85330     } catch (std::out_of_range& e) {
85331       {
85332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85333       };
85334     } catch (std::exception& e) {
85335       {
85336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85337       };
85338     } catch (...) {
85339       {
85340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85341       };
85342     }
85343   }
85344 }
85345
85346
85347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85348   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85349   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85350
85351   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85352   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85353   {
85354     try {
85355       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85356     } catch (std::out_of_range& e) {
85357       {
85358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85359       };
85360     } catch (std::exception& e) {
85361       {
85362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85363       };
85364     } catch (...) {
85365       {
85366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85367       };
85368     }
85369   }
85370 }
85371
85372
85373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85374   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85375   Dali::Toolkit::VideoView *arg2 = 0 ;
85376
85377   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85378   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85379   if (!arg2) {
85380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85381     return ;
85382   }
85383   {
85384     try {
85385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85386     } catch (std::out_of_range& e) {
85387       {
85388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85389       };
85390     } catch (std::exception& e) {
85391       {
85392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85393       };
85394     } catch (...) {
85395       {
85396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85397       };
85398     }
85399   }
85400 }
85401
85402
85403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85404   void * jresult ;
85405   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85406
85407   {
85408     try {
85409       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85410     } catch (std::out_of_range& e) {
85411       {
85412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85413       };
85414     } catch (std::exception& e) {
85415       {
85416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85417       };
85418     } catch (...) {
85419       {
85420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85421       };
85422     }
85423   }
85424   jresult = (void *)result;
85425   return jresult;
85426 }
85427
85428
85429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85430   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85431
85432   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85433   {
85434     try {
85435       delete arg1;
85436     } catch (std::out_of_range& e) {
85437       {
85438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85439       };
85440     } catch (std::exception& e) {
85441       {
85442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85443       };
85444     } catch (...) {
85445       {
85446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85447       };
85448     }
85449   }
85450 }
85451
85452
85453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85454   unsigned int jresult ;
85455   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85456   bool result;
85457
85458   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85459   {
85460     try {
85461       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85462     } catch (std::out_of_range& e) {
85463       {
85464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85465       };
85466     } catch (std::exception& e) {
85467       {
85468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85469       };
85470     } catch (...) {
85471       {
85472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85473       };
85474     }
85475   }
85476   jresult = result;
85477   return jresult;
85478 }
85479
85480
85481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85482   unsigned long jresult ;
85483   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85484   std::size_t result;
85485
85486   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85487   {
85488     try {
85489       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85490     } catch (std::out_of_range& e) {
85491       {
85492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85493       };
85494     } catch (std::exception& e) {
85495       {
85496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85497       };
85498     } catch (...) {
85499       {
85500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85501       };
85502     }
85503   }
85504   jresult = (unsigned long)result;
85505   return jresult;
85506 }
85507
85508
85509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85510   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85511   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85512
85513   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85514   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85515   {
85516     try {
85517       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85518     } catch (std::out_of_range& e) {
85519       {
85520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85521       };
85522     } catch (std::exception& e) {
85523       {
85524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85525       };
85526     } catch (...) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85529       };
85530     }
85531   }
85532 }
85533
85534
85535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85536   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85537   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85538
85539   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85540   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85541   {
85542     try {
85543       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85544     } catch (std::out_of_range& e) {
85545       {
85546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85547       };
85548     } catch (std::exception& e) {
85549       {
85550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85555       };
85556     }
85557   }
85558 }
85559
85560
85561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85562   unsigned int jresult ;
85563   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85564   Dali::Toolkit::Slider arg2 ;
85565   float arg3 ;
85566   Dali::Toolkit::Slider *argp2 ;
85567   bool result;
85568
85569   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85570   argp2 = (Dali::Toolkit::Slider *)jarg2;
85571   if (!argp2) {
85572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85573     return 0;
85574   }
85575   arg2 = *argp2;
85576   arg3 = (float)jarg3;
85577   {
85578     try {
85579       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85580     } catch (std::out_of_range& e) {
85581       {
85582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85583       };
85584     } catch (std::exception& e) {
85585       {
85586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (...) {
85589       {
85590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85591       };
85592     }
85593   }
85594   jresult = result;
85595   return jresult;
85596 }
85597
85598
85599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85600   void * jresult ;
85601   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85602
85603   {
85604     try {
85605       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (...) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85617       };
85618     }
85619   }
85620   jresult = (void *)result;
85621   return jresult;
85622 }
85623
85624
85625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85626   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85627
85628   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85629   {
85630     try {
85631       delete arg1;
85632     } catch (std::out_of_range& e) {
85633       {
85634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85635       };
85636     } catch (std::exception& e) {
85637       {
85638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85639       };
85640     } catch (...) {
85641       {
85642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85643       };
85644     }
85645   }
85646 }
85647
85648
85649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85650   unsigned int jresult ;
85651   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85652   bool result;
85653
85654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85655   {
85656     try {
85657       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85658     } catch (std::out_of_range& e) {
85659       {
85660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85661       };
85662     } catch (std::exception& e) {
85663       {
85664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85665       };
85666     } catch (...) {
85667       {
85668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85669       };
85670     }
85671   }
85672   jresult = result;
85673   return jresult;
85674 }
85675
85676
85677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85678   unsigned long jresult ;
85679   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85680   std::size_t result;
85681
85682   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85683   {
85684     try {
85685       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85686     } catch (std::out_of_range& e) {
85687       {
85688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85689       };
85690     } catch (std::exception& e) {
85691       {
85692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85693       };
85694     } catch (...) {
85695       {
85696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85697       };
85698     }
85699   }
85700   jresult = (unsigned long)result;
85701   return jresult;
85702 }
85703
85704
85705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85706   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85707   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85708
85709   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85710   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85711   {
85712     try {
85713       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85714     } catch (std::out_of_range& e) {
85715       {
85716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85717       };
85718     } catch (std::exception& e) {
85719       {
85720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85721       };
85722     } catch (...) {
85723       {
85724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85725       };
85726     }
85727   }
85728 }
85729
85730
85731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85732   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85733   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85734
85735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85736   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85737   {
85738     try {
85739       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85740     } catch (std::out_of_range& e) {
85741       {
85742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85743       };
85744     } catch (std::exception& e) {
85745       {
85746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85747       };
85748     } catch (...) {
85749       {
85750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85751       };
85752     }
85753   }
85754 }
85755
85756
85757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85758   unsigned int jresult ;
85759   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85760   Dali::Toolkit::Slider arg2 ;
85761   int arg3 ;
85762   Dali::Toolkit::Slider *argp2 ;
85763   bool result;
85764
85765   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85766   argp2 = (Dali::Toolkit::Slider *)jarg2;
85767   if (!argp2) {
85768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85769     return 0;
85770   }
85771   arg2 = *argp2;
85772   arg3 = (int)jarg3;
85773   {
85774     try {
85775       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85776     } catch (std::out_of_range& e) {
85777       {
85778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85779       };
85780     } catch (std::exception& e) {
85781       {
85782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85783       };
85784     } catch (...) {
85785       {
85786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85787       };
85788     }
85789   }
85790   jresult = result;
85791   return jresult;
85792 }
85793
85794
85795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85796   void * jresult ;
85797   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85798
85799   {
85800     try {
85801       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85802     } catch (std::out_of_range& e) {
85803       {
85804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85805       };
85806     } catch (std::exception& e) {
85807       {
85808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (...) {
85811       {
85812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85813       };
85814     }
85815   }
85816   jresult = (void *)result;
85817   return jresult;
85818 }
85819
85820
85821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85822   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85823
85824   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85825   {
85826     try {
85827       delete arg1;
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85839       };
85840     }
85841   }
85842 }
85843
85844
85845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85846   void * jresult ;
85847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85848
85849   {
85850     try {
85851       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85852     } catch (std::out_of_range& e) {
85853       {
85854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (std::exception& e) {
85857       {
85858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85859       };
85860     } catch (...) {
85861       {
85862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85863       };
85864     }
85865   }
85866   jresult = (void *)result;
85867   return jresult;
85868 }
85869
85870
85871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85872   void * jresult ;
85873   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85875
85876   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85877   {
85878     try {
85879       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85880     } catch (std::out_of_range& e) {
85881       {
85882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (std::exception& e) {
85885       {
85886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85887       };
85888     } catch (...) {
85889       {
85890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85891       };
85892     }
85893   }
85894   jresult = (void *)result;
85895   return jresult;
85896 }
85897
85898
85899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85900   void * jresult ;
85901   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85902   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85903
85904   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85905   if (!arg1) {
85906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85907     return 0;
85908   }
85909   {
85910     try {
85911       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85912     } catch (std::out_of_range& e) {
85913       {
85914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85915       };
85916     } catch (std::exception& e) {
85917       {
85918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85919       };
85920     } catch (...) {
85921       {
85922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85923       };
85924     }
85925   }
85926   jresult = (void *)result;
85927   return jresult;
85928 }
85929
85930
85931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85933
85934   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85935   {
85936     try {
85937       delete arg1;
85938     } catch (std::out_of_range& e) {
85939       {
85940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85941       };
85942     } catch (std::exception& e) {
85943       {
85944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85945       };
85946     } catch (...) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85949       };
85950     }
85951   }
85952 }
85953
85954
85955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85956   void * jresult ;
85957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85958   Dali::Toolkit::Ruler *result = 0 ;
85959
85960   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85961   {
85962     try {
85963       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
85964     } catch (std::out_of_range& e) {
85965       {
85966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (std::exception& e) {
85969       {
85970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978   jresult = (void *)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85984   void * jresult ;
85985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85986   Dali::Toolkit::Ruler *result = 0 ;
85987
85988   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85989   {
85990     try {
85991       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85992     } catch (std::out_of_range& e) {
85993       {
85994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (std::exception& e) {
85997       {
85998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85999       };
86000     } catch (...) {
86001       {
86002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86003       };
86004     }
86005   }
86006   jresult = (void *)result;
86007   return jresult;
86008 }
86009
86010
86011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
86012   void * jresult ;
86013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86014   Dali::Toolkit::Ruler *result = 0 ;
86015
86016   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86017   {
86018     try {
86019       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
86020     } catch (std::out_of_range& e) {
86021       {
86022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86023       };
86024     } catch (std::exception& e) {
86025       {
86026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86027       };
86028     } catch (...) {
86029       {
86030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86031       };
86032     }
86033   }
86034   jresult = (void *)result;
86035   return jresult;
86036 }
86037
86038
86039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
86040   void * jresult ;
86041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86042   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
86043   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86044
86045   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86046   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86047   if (!arg2) {
86048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86049     return 0;
86050   }
86051   {
86052     try {
86053       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86054     } catch (std::out_of_range& e) {
86055       {
86056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86057       };
86058     } catch (std::exception& e) {
86059       {
86060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86061       };
86062     } catch (...) {
86063       {
86064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86065       };
86066     }
86067   }
86068   jresult = (void *)result;
86069   return jresult;
86070 }
86071
86072
86073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86074   void * jresult ;
86075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86076   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86078
86079   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86080   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86081   {
86082     try {
86083       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86084     } catch (std::out_of_range& e) {
86085       {
86086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86087       };
86088     } catch (std::exception& e) {
86089       {
86090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (...) {
86093       {
86094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86095       };
86096     }
86097   }
86098   jresult = (void *)result;
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86104   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86105
86106   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86107   {
86108     try {
86109       (arg1)->Reset();
86110     } catch (std::out_of_range& e) {
86111       {
86112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86113       };
86114     } catch (std::exception& e) {
86115       {
86116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86117       };
86118     } catch (...) {
86119       {
86120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86121       };
86122     }
86123   }
86124 }
86125
86126
86127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86129   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86130
86131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86132   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86133   {
86134     try {
86135       (arg1)->Reset(arg2);
86136     } catch (std::out_of_range& e) {
86137       {
86138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86139       };
86140     } catch (std::exception& e) {
86141       {
86142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86147       };
86148     }
86149   }
86150 }
86151
86152
86153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86154   void * jresult ;
86155   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86156   Dali::Toolkit::Ruler *result = 0 ;
86157
86158   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86159   {
86160     try {
86161       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (...) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86173       };
86174     }
86175   }
86176   jresult = (void *)result;
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86182   float jresult ;
86183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86184   float arg2 ;
86185   float arg3 ;
86186   float result;
86187
86188   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86189   arg2 = (float)jarg2;
86190   arg3 = (float)jarg3;
86191   {
86192     try {
86193       result = (float)(*arg1)->Snap(arg2,arg3);
86194     } catch (std::out_of_range& e) {
86195       {
86196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86197       };
86198     } catch (std::exception& e) {
86199       {
86200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (...) {
86203       {
86204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86205       };
86206     }
86207   }
86208   jresult = result;
86209   return jresult;
86210 }
86211
86212
86213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86214   float jresult ;
86215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86216   float arg2 ;
86217   float result;
86218
86219   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86220   arg2 = (float)jarg2;
86221   {
86222     try {
86223       result = (float)(*arg1)->Snap(arg2);
86224     } catch (std::out_of_range& e) {
86225       {
86226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (std::exception& e) {
86229       {
86230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (...) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86235       };
86236     }
86237   }
86238   jresult = result;
86239   return jresult;
86240 }
86241
86242
86243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86244   float jresult ;
86245   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86246   unsigned int arg2 ;
86247   unsigned int *arg3 = 0 ;
86248   bool arg4 ;
86249   float result;
86250
86251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86252   arg2 = (unsigned int)jarg2;
86253   arg3 = (unsigned int *)jarg3;
86254   arg4 = jarg4 ? true : false;
86255   {
86256     try {
86257       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86258     } catch (std::out_of_range& e) {
86259       {
86260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86261       };
86262     } catch (std::exception& e) {
86263       {
86264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (...) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86269       };
86270     }
86271   }
86272   jresult = result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86278   unsigned int jresult ;
86279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86280   float arg2 ;
86281   bool arg3 ;
86282   unsigned int result;
86283
86284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86285   arg2 = (float)jarg2;
86286   arg3 = jarg3 ? true : false;
86287   {
86288     try {
86289       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86290     } catch (std::out_of_range& e) {
86291       {
86292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (std::exception& e) {
86295       {
86296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86297       };
86298     } catch (...) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86301       };
86302     }
86303   }
86304   jresult = result;
86305   return jresult;
86306 }
86307
86308
86309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86310   unsigned int jresult ;
86311   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86312   unsigned int result;
86313
86314   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86315   {
86316     try {
86317       result = (unsigned int)(*arg1)->GetTotalPages();
86318     } catch (std::out_of_range& e) {
86319       {
86320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (std::exception& e) {
86323       {
86324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (...) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86329       };
86330     }
86331   }
86332   jresult = result;
86333   return jresult;
86334 }
86335
86336
86337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86338   int jresult ;
86339   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86340   Dali::Toolkit::Ruler::RulerType result;
86341
86342   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86343   {
86344     try {
86345       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86346     } catch (std::out_of_range& e) {
86347       {
86348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86349       };
86350     } catch (std::exception& e) {
86351       {
86352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (...) {
86355       {
86356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86357       };
86358     }
86359   }
86360   jresult = (int)result;
86361   return jresult;
86362 }
86363
86364
86365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86366   unsigned int jresult ;
86367   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86368   bool result;
86369
86370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86371   {
86372     try {
86373       result = (bool)(*arg1)->IsEnabled();
86374     } catch (std::out_of_range& e) {
86375       {
86376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86377       };
86378     } catch (std::exception& e) {
86379       {
86380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86381       };
86382     } catch (...) {
86383       {
86384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86385       };
86386     }
86387   }
86388   jresult = result;
86389   return jresult;
86390 }
86391
86392
86393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86395
86396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86397   {
86398     try {
86399       (*arg1)->Enable();
86400     } catch (std::out_of_range& e) {
86401       {
86402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86403       };
86404     } catch (std::exception& e) {
86405       {
86406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86407       };
86408     } catch (...) {
86409       {
86410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86411       };
86412     }
86413   }
86414 }
86415
86416
86417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86419
86420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86421   {
86422     try {
86423       (*arg1)->Disable();
86424     } catch (std::out_of_range& e) {
86425       {
86426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86427       };
86428     } catch (std::exception& e) {
86429       {
86430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86435       };
86436     }
86437   }
86438 }
86439
86440
86441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86442   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86443   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86444   Dali::Toolkit::RulerDomain *argp2 ;
86445
86446   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86447   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86448   if (!argp2) {
86449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86450     return ;
86451   }
86452   arg2 = *argp2;
86453   {
86454     try {
86455       (*arg1)->SetDomain(arg2);
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86463       };
86464     } catch (...) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86467       };
86468     }
86469   }
86470 }
86471
86472
86473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86474   void * jresult ;
86475   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86476   Dali::Toolkit::RulerDomain *result = 0 ;
86477
86478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86479   {
86480     try {
86481       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (...) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86493       };
86494     }
86495   }
86496   jresult = (void *)result;
86497   return jresult;
86498 }
86499
86500
86501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86502   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86503
86504   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86505   {
86506     try {
86507       (*arg1)->DisableDomain();
86508     } catch (std::out_of_range& e) {
86509       {
86510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86511       };
86512     } catch (std::exception& e) {
86513       {
86514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86519       };
86520     }
86521   }
86522 }
86523
86524
86525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86526   float jresult ;
86527   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86528   float arg2 ;
86529   float arg3 ;
86530   float arg4 ;
86531   float result;
86532
86533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86534   arg2 = (float)jarg2;
86535   arg3 = (float)jarg3;
86536   arg4 = (float)jarg4;
86537   {
86538     try {
86539       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86540     } catch (std::out_of_range& e) {
86541       {
86542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86543       };
86544     } catch (std::exception& e) {
86545       {
86546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86551       };
86552     }
86553   }
86554   jresult = result;
86555   return jresult;
86556 }
86557
86558
86559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86560   float jresult ;
86561   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86562   float arg2 ;
86563   float arg3 ;
86564   float result;
86565
86566   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86567   arg2 = (float)jarg2;
86568   arg3 = (float)jarg3;
86569   {
86570     try {
86571       result = (float)(*arg1)->Clamp(arg2,arg3);
86572     } catch (std::out_of_range& e) {
86573       {
86574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86575       };
86576     } catch (std::exception& e) {
86577       {
86578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86579       };
86580     } catch (...) {
86581       {
86582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86583       };
86584     }
86585   }
86586   jresult = result;
86587   return jresult;
86588 }
86589
86590
86591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86592   float jresult ;
86593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86594   float arg2 ;
86595   float result;
86596
86597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86598   arg2 = (float)jarg2;
86599   {
86600     try {
86601       result = (float)(*arg1)->Clamp(arg2);
86602     } catch (std::out_of_range& e) {
86603       {
86604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86605       };
86606     } catch (std::exception& e) {
86607       {
86608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86609       };
86610     } catch (...) {
86611       {
86612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86613       };
86614     }
86615   }
86616   jresult = result;
86617   return jresult;
86618 }
86619
86620
86621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86622   float jresult ;
86623   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86624   float arg2 ;
86625   float arg3 ;
86626   float arg4 ;
86627   Dali::Toolkit::ClampState *arg5 = 0 ;
86628   float result;
86629
86630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86631   arg2 = (float)jarg2;
86632   arg3 = (float)jarg3;
86633   arg4 = (float)jarg4;
86634   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86635   if (!arg5) {
86636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86637     return 0;
86638   }
86639   {
86640     try {
86641       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86642     } catch (std::out_of_range& e) {
86643       {
86644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86645       };
86646     } catch (std::exception& e) {
86647       {
86648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86649       };
86650     } catch (...) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86653       };
86654     }
86655   }
86656   jresult = result;
86657   return jresult;
86658 }
86659
86660
86661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86662   float jresult ;
86663   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86664   float arg2 ;
86665   float arg3 ;
86666   float arg4 ;
86667   float arg5 ;
86668   float result;
86669
86670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86671   arg2 = (float)jarg2;
86672   arg3 = (float)jarg3;
86673   arg4 = (float)jarg4;
86674   arg5 = (float)jarg5;
86675   {
86676     try {
86677       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86678     } catch (std::out_of_range& e) {
86679       {
86680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86681       };
86682     } catch (std::exception& e) {
86683       {
86684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86685       };
86686     } catch (...) {
86687       {
86688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86689       };
86690     }
86691   }
86692   jresult = result;
86693   return jresult;
86694 }
86695
86696
86697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86698   float jresult ;
86699   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86700   float arg2 ;
86701   float arg3 ;
86702   float arg4 ;
86703   float result;
86704
86705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86706   arg2 = (float)jarg2;
86707   arg3 = (float)jarg3;
86708   arg4 = (float)jarg4;
86709   {
86710     try {
86711       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86712     } catch (std::out_of_range& e) {
86713       {
86714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86715       };
86716     } catch (std::exception& e) {
86717       {
86718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86719       };
86720     } catch (...) {
86721       {
86722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86723       };
86724     }
86725   }
86726   jresult = result;
86727   return jresult;
86728 }
86729
86730
86731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86732   float jresult ;
86733   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86734   float arg2 ;
86735   float arg3 ;
86736   float result;
86737
86738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86739   arg2 = (float)jarg2;
86740   arg3 = (float)jarg3;
86741   {
86742     try {
86743       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86744     } catch (std::out_of_range& e) {
86745       {
86746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86747       };
86748     } catch (std::exception& e) {
86749       {
86750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (...) {
86753       {
86754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86755       };
86756     }
86757   }
86758   jresult = result;
86759   return jresult;
86760 }
86761
86762
86763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86764   float jresult ;
86765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86766   float arg2 ;
86767   float result;
86768
86769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86770   arg2 = (float)jarg2;
86771   {
86772     try {
86773       result = (float)(*arg1)->SnapAndClamp(arg2);
86774     } catch (std::out_of_range& e) {
86775       {
86776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86777       };
86778     } catch (std::exception& e) {
86779       {
86780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86781       };
86782     } catch (...) {
86783       {
86784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86785       };
86786     }
86787   }
86788   jresult = result;
86789   return jresult;
86790 }
86791
86792
86793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86794   float jresult ;
86795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86796   float arg2 ;
86797   float arg3 ;
86798   float arg4 ;
86799   float arg5 ;
86800   Dali::Toolkit::ClampState *arg6 = 0 ;
86801   float result;
86802
86803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86804   arg2 = (float)jarg2;
86805   arg3 = (float)jarg3;
86806   arg4 = (float)jarg4;
86807   arg5 = (float)jarg5;
86808   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86809   if (!arg6) {
86810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86811     return 0;
86812   }
86813   {
86814     try {
86815       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86816     } catch (std::out_of_range& e) {
86817       {
86818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (std::exception& e) {
86821       {
86822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86823       };
86824     } catch (...) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86827       };
86828     }
86829   }
86830   jresult = result;
86831   return jresult;
86832 }
86833
86834
86835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86837
86838   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86839   {
86840     try {
86841       (*arg1)->Reference();
86842     } catch (std::out_of_range& e) {
86843       {
86844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86845       };
86846     } catch (std::exception& e) {
86847       {
86848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86849       };
86850     } catch (...) {
86851       {
86852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86853       };
86854     }
86855   }
86856 }
86857
86858
86859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86860   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86861
86862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86863   {
86864     try {
86865       (*arg1)->Unreference();
86866     } catch (std::out_of_range& e) {
86867       {
86868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86869       };
86870     } catch (std::exception& e) {
86871       {
86872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86873       };
86874     } catch (...) {
86875       {
86876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86877       };
86878     }
86879   }
86880 }
86881
86882
86883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86884   int jresult ;
86885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86886   int result;
86887
86888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86889   {
86890     try {
86891       result = (int)(*arg1)->ReferenceCount();
86892     } catch (std::out_of_range& e) {
86893       {
86894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86895       };
86896     } catch (std::exception& e) {
86897       {
86898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (...) {
86901       {
86902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86903       };
86904     }
86905   }
86906   jresult = result;
86907   return jresult;
86908 }
86909
86910
86911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86912   unsigned int jresult ;
86913   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86914   bool result;
86915
86916   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86917   {
86918     try {
86919       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86920     } catch (std::out_of_range& e) {
86921       {
86922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86923       };
86924     } catch (std::exception& e) {
86925       {
86926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (...) {
86929       {
86930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86931       };
86932     }
86933   }
86934   jresult = result;
86935   return jresult;
86936 }
86937
86938
86939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86940   unsigned long jresult ;
86941   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86942   std::size_t result;
86943
86944   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86945   {
86946     try {
86947       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86948     } catch (std::out_of_range& e) {
86949       {
86950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86951       };
86952     } catch (std::exception& e) {
86953       {
86954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86955       };
86956     } catch (...) {
86957       {
86958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86959       };
86960     }
86961   }
86962   jresult = (unsigned long)result;
86963   return jresult;
86964 }
86965
86966
86967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86968   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86969   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86970
86971   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86972   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86973   {
86974     try {
86975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86976     } catch (std::out_of_range& e) {
86977       {
86978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86979       };
86980     } catch (std::exception& e) {
86981       {
86982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86983       };
86984     } catch (...) {
86985       {
86986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86987       };
86988     }
86989   }
86990 }
86991
86992
86993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86994   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86995   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86996
86997   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86998   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86999   {
87000     try {
87001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87009       };
87010     } catch (...) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87013       };
87014     }
87015   }
87016 }
87017
87018
87019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
87020   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87021   Dali::Toolkit::Control arg2 ;
87022   Dali::Toolkit::Control *argp2 ;
87023
87024   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87025   argp2 = (Dali::Toolkit::Control *)jarg2;
87026   if (!argp2) {
87027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87028     return ;
87029   }
87030   arg2 = *argp2;
87031   {
87032     try {
87033       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (...) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87045       };
87046     }
87047   }
87048 }
87049
87050
87051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87052   void * jresult ;
87053   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87054
87055   {
87056     try {
87057       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87058     } catch (std::out_of_range& e) {
87059       {
87060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87061       };
87062     } catch (std::exception& e) {
87063       {
87064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87065       };
87066     } catch (...) {
87067       {
87068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87069       };
87070     }
87071   }
87072   jresult = (void *)result;
87073   return jresult;
87074 }
87075
87076
87077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87078   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87079
87080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87081   {
87082     try {
87083       delete arg1;
87084     } catch (std::out_of_range& e) {
87085       {
87086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87087       };
87088     } catch (std::exception& e) {
87089       {
87090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87091       };
87092     } catch (...) {
87093       {
87094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87095       };
87096     }
87097   }
87098 }
87099
87100 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87101   Dali::RefObject *result = NULL;
87102
87103   if (arg1)
87104   {
87105     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87106   }
87107   return result;
87108 }
87109
87110 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87111     return (Dali::RefObject *)jarg1;
87112 }
87113
87114 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87115     return (Dali::SignalObserver *)jarg1;
87116 }
87117
87118 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87119     return (Dali::ConnectionTrackerInterface *)jarg1;
87120 }
87121
87122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87123     return (Dali::BaseHandle *)jarg1;
87124 }
87125
87126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87127     return (Dali::BaseHandle *)jarg1;
87128 }
87129
87130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87131     return (Dali::BaseHandle *)jarg1;
87132 }
87133
87134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87135     return (Dali::BaseHandle *)jarg1;
87136 }
87137
87138 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87139     return (Dali::BaseHandle *)jarg1;
87140 }
87141
87142 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87143     return (Dali::BaseHandle *)jarg1;
87144 }
87145
87146 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87147     return (Dali::BaseHandle *)jarg1;
87148 }
87149
87150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87151     return (Dali::BaseHandle *)jarg1;
87152 }
87153
87154 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87155     return (Dali::BaseHandle *)jarg1;
87156 }
87157
87158 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87159     return (Dali::BaseHandle *)jarg1;
87160 }
87161
87162 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87163     return (Dali::BaseHandle *)jarg1;
87164 }
87165
87166 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87167     return (Dali::BaseHandle *)jarg1;
87168 }
87169
87170 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87171     return (Dali::BaseHandle *)jarg1;
87172 }
87173
87174 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87175     return (Dali::Handle *)jarg1;
87176 }
87177
87178 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87179     return (Dali::Handle *)jarg1;
87180 }
87181
87182 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87183     return (Dali::BaseHandle *)jarg1;
87184 }
87185
87186 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87187     return (Dali::BaseHandle *)jarg1;
87188 }
87189
87190 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87191     return (Dali::Handle *)jarg1;
87192 }
87193
87194 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87195     return (Dali::BaseHandle *)jarg1;
87196 }
87197
87198 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87199     return (Dali::Handle *)jarg1;
87200 }
87201
87202 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87203     return (Dali::GestureDetector *)jarg1;
87204 }
87205
87206 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87207     return (Dali::Gesture *)jarg1;
87208 }
87209
87210 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87211     return (Dali::Handle *)jarg1;
87212 }
87213
87214 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87215     return (Dali::Actor *)jarg1;
87216 }
87217
87218 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87219     return (Dali::BaseHandle *)jarg1;
87220 }
87221
87222 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87223     return (Dali::RefObject *)jarg1;
87224 }
87225
87226 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87227     return (Dali::Actor *)jarg1;
87228 }
87229
87230 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87231     return (Dali::GestureDetector *)jarg1;
87232 }
87233
87234 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87235     return (Dali::Gesture *)jarg1;
87236 }
87237
87238 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87239     return (Dali::GestureDetector *)jarg1;
87240 }
87241
87242 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87243     return (Dali::Gesture *)jarg1;
87244 }
87245
87246 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87247     return (Dali::GestureDetector *)jarg1;
87248 }
87249
87250 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87251     return (Dali::Gesture *)jarg1;
87252 }
87253
87254 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87255     return (Dali::BaseHandle *)jarg1;
87256 }
87257
87258 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87259     return (Dali::Handle *)jarg1;
87260 }
87261
87262 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87263     return (Dali::Handle *)jarg1;
87264 }
87265
87266 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87267     return (Dali::Handle *)jarg1;
87268 }
87269
87270 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87271     return (Dali::Image *)jarg1;
87272 }
87273
87274 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87275     return (Dali::Image *)jarg1;
87276 }
87277
87278 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87279     return (Dali::Image *)jarg1;
87280 }
87281
87282 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87283     return (Dali::RefObject *)jarg1;
87284 }
87285
87286 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87287     return (Dali::Image *)jarg1;
87288 }
87289
87290 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87291     return (Dali::Image *)jarg1;
87292 }
87293
87294 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87295     return (Dali::ResourceImage *)jarg1;
87296 }
87297
87298 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87299     return (Dali::Actor *)jarg1;
87300 }
87301
87302 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87303     return (Dali::BaseHandle *)jarg1;
87304 }
87305
87306 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87307     return (Dali::BaseHandle *)jarg1;
87308 }
87309
87310
87311 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87312     return (Dali::BaseHandle *)jarg1;
87313 }
87314
87315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87316     return (Dali::BaseHandle *)jarg1;
87317 }
87318
87319 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87320     return (Dali::CustomActorImpl *)jarg1;
87321 }
87322
87323 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87324     return (Dali::CustomActor *)jarg1;
87325 }
87326
87327 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87328     return (Dali::BaseHandle *)jarg1;
87329 }
87330
87331 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87332     return (Dali::Toolkit::Control *)jarg1;
87333 }
87334
87335 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87336     return (Dali::Toolkit::Control *)jarg1;
87337 }
87338
87339 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87340     return (Dali::Toolkit::Button *)jarg1;
87341 }
87342
87343 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87344     return (Dali::Toolkit::Button *)jarg1;
87345 }
87346
87347 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87348     return (Dali::Toolkit::Button *)jarg1;
87349 }
87350
87351 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87352     return (Dali::Toolkit::Control *)jarg1;
87353 }
87354
87355 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87356     return (Dali::Toolkit::Control *)jarg1;
87357 }
87358
87359 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87360     return (Dali::Toolkit::Control *)jarg1;
87361 }
87362
87363 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87364     return (Dali::Toolkit::Control *)jarg1;
87365 }
87366
87367 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87368     return (Dali::Toolkit::Control *)jarg1;
87369 }
87370
87371 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87372     return (Dali::RefObject *)jarg1;
87373 }
87374
87375 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87376     return (Dali::Toolkit::Scrollable *)jarg1;
87377 }
87378
87379 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87380     return (Dali::BaseHandle *)jarg1;
87381 }
87382
87383 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87384     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87385 }
87386
87387 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87388     return (Dali::RefObject *)jarg1;
87389 }
87390
87391 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87392     return (Dali::Toolkit::Ruler *)jarg1;
87393 }
87394
87395 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87396     return (Dali::Toolkit::Ruler *)jarg1;
87397 }
87398
87399 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87400     return (Dali::Toolkit::Scrollable *)jarg1;
87401 }
87402
87403 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87404     return (Dali::Toolkit::Control *)jarg1;
87405 }
87406
87407
87408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87409     return (Dali::Toolkit::Control *)jarg1;
87410 }
87411
87412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87413     return (Dali::BaseHandle *)jarg1;
87414 }
87415
87416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87417     return (Dali::BaseHandle *)jarg1;
87418 }
87419
87420 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87421     return (Dali::Toolkit::Control *)jarg1;
87422 }
87423
87424 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87425     return (Dali::Toolkit::Control *)jarg1;
87426 }
87427
87428 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87429     return (Dali::Toolkit::Control *)jarg1;
87430 }
87431
87432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87433     return (Dali::Toolkit::Control *)jarg1;
87434 }
87435
87436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87437     return (Dali::Toolkit::Control *)jarg1;
87438 }
87439
87440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87441     return (Dali::Toolkit::Control *)jarg1;
87442 }
87443
87444 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87445     return (Dali::Toolkit::PageTurnView *)jarg1;
87446 }
87447
87448 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87449     return (Dali::Toolkit::PageTurnView *)jarg1;
87450 }
87451
87452 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87453     return (Dali::Toolkit::Button *)jarg1;
87454 }
87455
87456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87457     return (Dali::BaseHandle *)jarg1;
87458 }
87459
87460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87461     return (Dali::BaseHandle *)jarg1;
87462 }
87463
87464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87465     return (Dali::BaseHandle *)jarg1;
87466 }
87467
87468
87469 #ifdef __cplusplus
87470 }
87471 #endif